SettingsDialogImpl::SettingsDialogImpl(QWidget *parent)
: QDialog(parent)
{
ui.setupUi(this);
//setup the whole ui from settings
Settings* settings = Settings::Instance();
connect(ui.sortCheckBox, SIGNAL(stateChanged(int)), this, SLOT(sortStateChanged(int)));
if(settings->getSort() == true)
ui.sortCheckBox->setCheckState(Qt::Checked);
else
{
ui.sortCheckBox->setCheckState(Qt::Unchecked);
ui.sortOngoingCheckBox->setEnabled(false);
ui.sortPriorCheckBox->setEnabled(false);
ui.sortPriorLabel->setEnabled(false);
}
connect(ui.buttonBox, SIGNAL(accepted()), this, SLOT(acceptClicked()));
if(settings->getOngoingSort() == true)
ui.sortOngoingCheckBox->setCheckState(Qt::Checked);
else
ui.sortOngoingCheckBox->setCheckState(Qt::Unchecked);
if(settings->getPriorSort() == true)
ui.sortPriorCheckBox->setCheckState(Qt::Checked);
else
ui.sortPriorCheckBox->setCheckState(Qt::Unchecked);
if(settings->getReloadSort() == true)
ui.sortReloadCheckBox->setCheckState(Qt::Checked);
else
ui.sortReloadCheckBox->setCheckState(Qt::Unchecked);
if(settings->getConvertNames() == true)
ui.convertnamescheckbox->setCheckState(Qt::Checked);
else
ui.convertnamescheckbox->setCheckState(Qt::Unchecked);
if(settings->getScanMedia() == true)
ui.scanmediabox->setCheckState(Qt::Checked);
else
ui.scanmediabox->setCheckState(Qt::Unchecked);
ui.opacitySpinbox->setValue(settings->getOpacity());
// qDebug() << settings->getSort() << settings->getOngoingSort() << settings->getPriorSort();
ui.tableWidget->setColumnWidth(0,300);
ui.tableWidget->setColumnWidth(0,200);
QTableWidgetItem* name = new QTableWidgetItem("Player");
ui.tableWidget->setHorizontalHeaderItem(0,name);
QTableWidgetItem* args = new QTableWidgetItem("Args");
ui.tableWidget->setHorizontalHeaderItem(1,args);
QList<QPair<QString, QString> > players = Settings::Instance()->getPlayerList();
for(int i=0; i<players.size(); i++)
{
QTableWidgetItem* playeritem = new QTableWidgetItem( players.at(i).first );
playeritem->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* argitem = new QTableWidgetItem( players.at(i).second );
//argitem->setFlags(Qt::ItemIsEnabled);
int row = ui.tableWidget->rowCount();
ui.tableWidget->insertRow(row);
ui.tableWidget->setItem(row, 0, playeritem);
ui.tableWidget->setItem(row, 1, argitem);
}
ui.settingsfilelabel->setText(Settings::Instance()->getSettingsFilename());
}
void rulesDialog::readTest( int index, QgsMapLayerRegistry* layerRegistry )
{
QString testName;
QString layer1Id;
QString layer2Id;
QString tolerance;
QgsProject* project = QgsProject::instance();
QString postfix = QString( "%1" ).arg( index );
testName = project->readEntry( "Topol", "/testname_" + postfix, "" );
tolerance = project->readEntry( "Topol", "/tolerance_" + postfix, "" );
layer1Id = project->readEntry( "Topol", "/layer1_" + postfix, "" );
layer2Id = project->readEntry( "Topol", "/layer2_" + postfix, "" );
QgsVectorLayer* l1;
if ( !( QgsVectorLayer* )layerRegistry->mapLayers().contains( layer1Id ) )
return;
l1 = ( QgsVectorLayer* )layerRegistry->mapLayers()[layer1Id];
if ( !l1 )
return;
QString layer1Name = l1->name();
QString layer2Name;
QgsVectorLayer* l2;
if ( mTestConfMap[testName].useSecondLayer )
{
if ( !( QgsVectorLayer* )layerRegistry->mapLayers().contains( layer2Id ) )
return;
else
{
l2 = ( QgsVectorLayer* )layerRegistry->mapLayers()[layer2Id];
layer2Name = l2->name();
}
}
else
layer2Name = "No layer";
int row = index;
mRulesTable->insertRow( row );
QTableWidgetItem* newItem;
newItem = new QTableWidgetItem( testName );
newItem->setFlags( newItem->flags() & ~Qt::ItemIsEditable );
mRulesTable->setItem( row, 0, newItem );
newItem = new QTableWidgetItem( layer1Name );
newItem->setFlags( newItem->flags() & ~Qt::ItemIsEditable );
mRulesTable->setItem( row, 1, newItem );
newItem = new QTableWidgetItem( layer2Name );
newItem->setFlags( newItem->flags() & ~Qt::ItemIsEditable );
mRulesTable->setItem( row, 2, newItem );
if ( mTestConfMap[testName].useTolerance )
newItem = new QTableWidgetItem( tolerance );
else
newItem = new QTableWidgetItem( QString( "No tolerance" ) );
newItem->setFlags( newItem->flags() & ~Qt::ItemIsEditable );
mRulesTable->setItem( row, 3, newItem );
// add layer ids to hidden columns
newItem = new QTableWidgetItem( layer1Id );
mRulesTable->setItem( row, 4, newItem );
newItem = new QTableWidgetItem( layer2Id );
mRulesTable->setItem( row, 5, newItem );
}
void Window::openFileOfItem(int row, int /* column */)
{
QTableWidgetItem *item = filesTable->item(row, 0);
QDesktopServices::openUrl(QUrl::fromLocalFile(currentDir.absoluteFilePath(item->text())));
}
void QgsGrassEdit::setAttributeTable( int field )
{
mAttributeTable->setRowCount( 0 );
QString *key = mProvider->key( field );
if ( !key->isEmpty() ) // Database link defined
{
QVector<QgsField> *cols = mProvider->columns( field );
mAttributeTable->setRowCount( cols->size() );
for ( int c = 0; c < cols->size(); c++ )
{
QgsField col = ( *cols )[c];
QTableWidgetItem *ti;
ti = new QTableWidgetItem( col.name() );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( c, 0, ti );
ti = new QTableWidgetItem( col.typeName() );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( c, 1, ti );
QString str;
str.sprintf( "%d", col.length() );
ti = new QTableWidgetItem( str );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( c, 2, ti );
}
}
else
{
mAttributeTable->setRowCount( 1 );
QTableWidgetItem *ti;
ti = new QTableWidgetItem( "cat" );
mAttributeTable->setItem( 0, 0, ti );
ti = new QTableWidgetItem( "integer" );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( 0, 1, ti );
ti = new QTableWidgetItem( "" );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( 0, 2, ti );
}
}
//Timer call to animate the graph bars.
void MonthView::on_growth_animation_timer_update()
{
if (prev_source_name != SOURCE_OTHER )
{
if((opacity <= 255) && (opacity >= 20 ))
{
opacity -= 25;
}else
{
if (opacity <= 20 )
{
opacity =20;
}
if (opacity >= 255)
{
opacity = 255;
}
}
}
bool isAnimationinProgress = false;
all_week_data = 0;
int data;
int sourceData;
int weekly_total = 0;
for(int row = 0; row < 6; row++)
{
weekly_total = 0;
for(int col = 0; col < 7; col++)
{
if ( m_vector_vector_view_selected_day_usage_values.size() != 42)
{
break;
}
QTableWidgetItem *item = ui->tblDates->item(row,col);
QVariant v = item->data(0);
StarRating r = v.value<StarRating>();
// int data;
// int sourceData;
if (ResetAnimation)
{
data = 0;
sourceData =0;
}
else
{
data = r.data_total;
sourceData = r.data_from_source;
}
if (opacity> 20 && prev_source_name != SOURCE_OTHER )
{
isAnimationinProgress = true;
sourceData = ((int)((qreal)(50 * ( m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][prev_source_name] )))/MaxUnit );
if (opacity < 50)
{
sourceData =0;
}
}
else if(data < ((int)((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 ) )
{
data++;
isAnimationinProgress = true;
}
else if(sourceData < ((int)((qreal)(50 * ( m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][currentSource] )))/MaxUnit ))
{
sourceData++;
isAnimationinProgress= true;
}
QDate dt = QDate::fromString(item->whatsThis());
bool isfuturedate = false;
if(dt.operator <= (QDate::currentDate()))
{
isfuturedate = true;
}
item->setData(0, qVariantFromValue(StarRating(r.date, data, sourceData, currentSource,r.max_data_total,r.max_source_data, opacity, prev_source_name, (qreal)((qreal)(50 * ( m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][prev_source_name] )))/MaxUnit , isfuturedate)));
if (opacity <= 20)
{
opacity= 255;
prev_source_name = SOURCE_OTHER;
}
if(sourceData >0 && isfuturedate)
{
weekly_total += m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][currentSource] ;
}
}
// if(weekly_total > 0)
{
all_week_data += weekly_total;
QTableWidgetItem *item_total = ui->tblDates->item(row, 7);
item_total->setData(0,
qVariantFromValue(StarRating(100,weekly_total,0, source_name,data,sourceData)));
}
}
ResetAnimation= false;
if (isAnimationinProgress == false )
{
prev_source_name =currentSource;
m_ptr_growth_animation_timer->stop();
}
emit(data_updated(all_week_data));
}
MPConfig::MPConfig(QWidget* parent)
: QFrame(parent)
{
setupUi(this);
mdevView->setRowCount(kMaxMidiPorts);
mdevView->verticalHeader()->hide();
mdevView->setSelectionMode(QAbstractItemView::SingleSelection);
mdevView->setShowGrid(false);
//popup = 0;
instrPopup = 0;
_showAliases = -1; // 0: Show first aliases, if available. Nah, stick with -1: none at first.
QStringList columnnames;
columnnames << tr("Port")
<< tr("GUI")
<< tr("N")
<< tr("I")
<< tr("O")
<< tr("Instr")
<< tr("D-Name")
<< tr("Ins")
<< tr("Outs")
<< tr("In Ch")
<< tr("Out Ch")
<< tr("State");
mdevView->setColumnCount(columnnames.size());
mdevView->setHorizontalHeaderLabels(columnnames);
for (int i = 0; i < columnnames.size(); ++i)
{
setWhatsThis(mdevView->horizontalHeaderItem(i), i);
setToolTip(mdevView->horizontalHeaderItem(i), i);
}
mdevView->setFocusPolicy(Qt::NoFocus);
//mdevView->horizontalHeader()->setMinimumSectionSize(60);
mdevView->horizontalHeader()->resizeSection(DEVCOL_NO, 50);
mdevView->horizontalHeader()->resizeSection(DEVCOL_CACHE_NRPN, 20);
mdevView->horizontalHeader()->resizeSection(DEVCOL_REC, 20);
mdevView->horizontalHeader()->resizeSection(DEVCOL_PLAY, 20);
mdevView->horizontalHeader()->resizeSection(DEVCOL_GUI, 40);
mdevView->horizontalHeader()->resizeSection(DEVCOL_INROUTES, 40);
mdevView->horizontalHeader()->resizeSection(DEVCOL_OUTROUTES, 140);
mdevView->horizontalHeader()->resizeSection(DEVCOL_DEF_IN_CHANS, 70);
mdevView->horizontalHeader()->resizeSection(DEVCOL_DEF_OUT_CHANS, 70);
mdevView->horizontalHeader()->resizeSection(DEVCOL_INSTR, 140);
mdevView->horizontalHeader()->resizeSection(DEVCOL_NAME, 140);
mdevView->horizontalHeader()->setStretchLastSection(true);
mdevView->horizontalHeader()->setDefaultAlignment(Qt::AlignVCenter | Qt::AlignLeft);
connect(mdevView, SIGNAL(itemPressed(QTableWidgetItem*)), this, SLOT(rbClicked(QTableWidgetItem*)));
connect(mdevView, SIGNAL(itemChanged(QTableWidgetItem*)), this, SLOT(mdevViewItemRenamed(QTableWidgetItem*)));
connect(song, SIGNAL(songChanged(int)), SLOT(songChanged(int)));
for (int i = kMaxMidiPorts - 1; i >= 0; --i)
{
mdevView->blockSignals(true); // otherwise itemChanged() is triggered and bad things happen.
QString s;
s.setNum(i + 1);
QTableWidgetItem* itemno = new QTableWidgetItem(s);
addItem(i, DEVCOL_NO, itemno, mdevView);
itemno->setTextAlignment(Qt::AlignHCenter);
itemno->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* itemstate = new QTableWidgetItem();
addItem(i, DEVCOL_STATE, itemstate, mdevView);
itemstate->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* iteminstr = new QTableWidgetItem();
addItem(i, DEVCOL_INSTR, iteminstr, mdevView);
iteminstr->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* itemname = new QTableWidgetItem;
addItem(i, DEVCOL_NAME, itemname, mdevView);
itemname->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* itemgui = new QTableWidgetItem;
addItem(i, DEVCOL_GUI, itemgui, mdevView);
itemgui->setTextAlignment(Qt::AlignHCenter);
itemgui->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* itemfb = new QTableWidgetItem;
addItem(i, DEVCOL_CACHE_NRPN, itemfb, mdevView);
itemfb->setTextAlignment(Qt::AlignHCenter);
itemfb->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* itemrec = new QTableWidgetItem;
addItem(i, DEVCOL_REC, itemrec, mdevView);
itemrec->setTextAlignment(Qt::AlignHCenter);
itemrec->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* itemplay = new QTableWidgetItem;
addItem(i, DEVCOL_PLAY, itemplay, mdevView);
itemplay->setTextAlignment(Qt::AlignHCenter);
itemplay->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* itemout = new QTableWidgetItem;
addItem(i, DEVCOL_OUTROUTES, itemout, mdevView);
itemout->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* itemin = new QTableWidgetItem;
addItem(i, DEVCOL_INROUTES, itemin, mdevView);
itemin->setFlags(Qt::ItemIsEnabled);
QTableWidgetItem* itemdefin = new QTableWidgetItem();
addItem(i, DEVCOL_DEF_IN_CHANS, itemdefin, mdevView);
itemdefin->setFlags(Qt::ItemIsEditable | Qt::ItemIsEnabled);
QTableWidgetItem* itemdefout = new QTableWidgetItem();
addItem(i, DEVCOL_DEF_OUT_CHANS, itemdefout, mdevView);
itemdefout->setFlags(Qt::ItemIsEditable | Qt::ItemIsEnabled);
mdevView->blockSignals(false);
}
songChanged(0);
}
void LapTimeComparisonDialog::updateData()
{
int scrollBarPosition = ui->tableWidget->verticalScrollBar()->sliderPosition();
QItemSelectionModel * selection = ui->tableWidget->selectionModel();
// for (int i = ui->tableWidget->rowCount()-1; i >= 0; --i)
// ui->tableWidget->removeRow(i);
QTableWidgetItem *item;
int firstLap = 99, lastLap = 0;
int index[4];
QString wTitle = "Lap time comparison: ";
for (int i = 0; i < 4; ++i)
{
index[i] = 0;
int idx = eventData.getDriverId(getNumber(i));
if (idx > 0)
{
if (i > 0)
wTitle += " - ";
wTitle += eventData.getDriversData()[idx-1].getDriverName();
if(!eventData.getDriversData()[idx-1].getLapData().isEmpty())
{
if (eventData.getDriversData()[idx-1].getLapData()[0].getLapNumber() < firstLap)
firstLap = eventData.getDriversData()[idx-1].getLapData()[0].getLapNumber();
if (eventData.getDriversData()[idx-1].getLapData().last().getLapNumber() > lastLap)
lastLap = eventData.getDriversData()[idx-1].getLapData().last().getLapNumber();
}
DriverData &dd = eventData.getDriversData()[idx-1];
QLabel *lab = qobject_cast<QLabel*>(ui->tableWidget->cellWidget(0, i+1));
lab->setPixmap(ImagesFactory::getInstance().getCarThumbnailsFactory().getCarThumbnail(dd.getNumber(), thumbnailsSize));//eventData.carImages[idx].scaledToWidth(120, Qt::SmoothTransformation));
}
else
{
QLabel *lab = qobject_cast<QLabel*>(ui->tableWidget->cellWidget(0, i+1));
lab->clear();
}
}
setWindowTitle(wTitle);
// ui->tableWidget->insertRow(0);
// ui->tableWidget->setRowHeight(0, 50);
int j = 0, k = firstLap;
for (; k <= lastLap; ++k, ++j)
{
int lapNo = lastLap - k + firstLap;
LapTime laps[4];
if (ui->tableWidget->rowCount() <= j+1)
ui->tableWidget->insertRow(j+1);
item = ui->tableWidget->item(j+1, 0);
if (!item)
{
item = new QTableWidgetItem(QString("%1.").arg(lapNo));
// item->setFlags(Qt::ItemIsSelectable);
item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
item->setTextColor(ColorsManager::getInstance().getColor(LTPackets::DEFAULT));
ui->tableWidget->setItem(j+1, 0, item);
}
else
item->setText(QString("%1.").arg(lapNo));
for (int i = 0; i < 4; ++i)
{
int idx = eventData.getDriverId(getNumber(i));
if (idx > 0 && !eventData.getDriversData()[idx-1].getLapData().isEmpty())
{
//int lapIndex = (reversedOrder ? eventData.driversData[idx-1].lapData.size() - index[i] - 1 : index[i]);
DriverData &dd = eventData.getDriversData()[idx-1];
LapData ld = dd.getLapData(lapNo);
// if (j == 0)
// {
// int idx = (dd.number > 13 ? dd.number-2 : dd.number-1) / 2;
// QLabel *lab = qobject_cast<QLabel*>(ui->tableWidget->cellWidget(0, i+1));
// lab->setPixmap(smallCarImg[idx]);//eventData.carImages[idx].scaledToWidth(120, Qt::SmoothTransformation));
// }
if (dd.getLapData().size() > index[i] && ld.getLapNumber() == lapNo && ld.getCarID() != -1)
{
laps[i] = ld.getTime();
item = ui->tableWidget->item(j+1, i+1);
if (!item)
{
item = new QTableWidgetItem(ld.getTime());
item->setTextAlignment(Qt::AlignCenter);
ui->tableWidget->setItem(j+1, i+1, item);
}
else
item->setText(ld.getTime());
if (ld.getTime().toString() == "IN PIT")
item->setText(item->text() + " (" + dd.getPitTime(ld.getLapNumber()) + ")");
++index[i];
}
else
{
item = ui->tableWidget->item(j+1, i+1);
if (item)
item->setText("");
}
}
else
{
if (j == 0)
{
// QLabel *lab = qobject_cast<QLabel*>(ui->tableWidget->cellWidget(0, i+1));
// if (lab)
// lab->clear();
}
item = ui->tableWidget->item(j+1, i+1);
if (item)
item->setText("");
}
}
int bestIdx = DriverData::lapDiff(laps);
if (bestIdx != -1)
{
for (int i = 0; i < 4; ++i)
{
if (i != bestIdx && laps[i].toString() != "" && laps[i].toString() != "IN PIT" && laps[i].toString() != "RETIRED" && !laps[i].toString().contains("LAP"))
{
item = ui->tableWidget->item(j+1, i+1);
if (item)
{
item->setText(item->text() + " (+"+QString::number(laps[i].toDouble(), 'f', 3)+")");
double msecs[3];
int ji = 0;
for (int j = 0; j < 4; ++j)
{
if (j != bestIdx)
{
if (laps[j].toString() != "")
msecs[ji++] = laps[j].toMsecs();
else
msecs[ji++] = 1000000;
}
}
double maxGap = std::max(std::max(msecs[0], msecs[1]), msecs[2]);
double minGap = std::min(std::min(msecs[0], msecs[1]), msecs[2]);
LTPackets::Colors color = LTPackets::YELLOW;
if (laps[i].toMsecs() == minGap)
color = LTPackets::WHITE;
else if (laps[i].toMsecs() == maxGap)
color = LTPackets::RED;
item->setTextColor(ColorsManager::getInstance().getColor(color));
}
}
else if (laps[i].toString() == "IN PIT" || laps[i].toString() == "RETIRED" || laps[i].toString().contains("LAP"))
{
item = ui->tableWidget->item(j+1, i+1);
item->setTextColor(ColorsManager::getInstance().getColor(LTPackets::RED));
}
}
item = ui->tableWidget->item(j+1, bestIdx+1);
if (item && laps[bestIdx].toString() != "IN PIT" && laps[bestIdx].toString() != "RETIRED" && !laps[bestIdx].toString().contains("LAP"))
item->setTextColor(ColorsManager::getInstance().getColor(LTPackets::GREEN));
}
ui->tableWidget->setRowHeight(j+1, 20);
}
for (int i = ui->tableWidget->rowCount()-1; i >= j+1; --i)
ui->tableWidget->removeRow(i);
ui->tableWidget->setSelectionModel(selection);
ui->tableWidget->verticalScrollBar()->setSliderPosition(scrollBarPosition);
}
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 HistoryForm::onTick01()
{
if (this->CurrentEdit == nullptr)
throw new Huggle::NullPointerException("local WikiEdit CurrentEdit", BOOST_CURRENT_FUNCTION);
if (this->RetrievingEdit && this->RetrievedEdit != nullptr)
{
if (this->RetrievedEdit->IsPostProcessed())
{
MainWindow::HuggleMain->ProcessEdit(this->RetrievedEdit, false, true);
this->RetrievingEdit = false;
this->RetrievedEdit = nullptr;
this->t1->stop();
this->MakeSelectedRowBold();
MainWindow::HuggleMain->wEditBar->RefreshPage();
}
return;
}
if (this->query == nullptr || !this->query->IsProcessed())
return;
if (this->query->IsFailed())
{
this->ui->pushButton->setEnabled(true);
Huggle::Syslog::HuggleLogs->ErrorLog(_l("history-failure"));
this->query = nullptr;
this->t1->stop();
return;
}
bool IsLatest = false;
QList<ApiQueryResultNode*> revision_data = this->query->GetApiQueryResult()->GetNodes("rev");
int x = 0;
while (x < revision_data.count())
{
ApiQueryResultNode *rv = revision_data.at(x);
WikiPageHistoryItem *item = new WikiPageHistoryItem();
if (rv->Attributes.contains("revid"))
{
item->RevID = rv->GetAttribute("revid");
}
else
{
x++;
continue;
}
bool founder = false;
item->Name = this->CurrentEdit->Page->PageName;
item->Site = this->CurrentEdit->GetSite();
if (rv->Attributes.contains("user"))
item->User = rv->GetAttribute("user");
if (rv->Attributes.contains("size"))
item->Size = rv->GetAttribute("size");
if (rv->Attributes.contains("timestamp"))
item->Date = rv->GetAttribute("timestamp");
if (rv->Attributes.contains("comment") && !rv->GetAttribute("comment").isEmpty())
item->Summary = rv->GetAttribute("comment");
this->ui->tableWidget->insertRow(x);
QIcon icon(":/huggle/pictures/Resources/blob-none.png");
if (this->CurrentEdit->Page->FounderKnown() && WikiUser::CompareUsernames(item->User, this->CurrentEdit->Page->GetFounder()))
founder = true;
if (WikiUtil::IsRevert(item->Summary))
{
item->Type = EditType_Revert;
icon = QIcon(":/huggle/pictures/Resources/blob-revert.png");
}
else if (WikiUser::IsIPv6(item->User) || WikiUser::IsIPv4(item->User))
{
item->Type = EditType_Anon;
icon = QIcon(":/huggle/pictures/Resources/blob-anon.png");
}
else if (this->CurrentEdit->GetSite()->GetProjectConfig()->WhiteList.contains(item->User))
{
item->Type = EditType_W;
icon = QIcon(":/huggle/pictures/Resources/blob-ignored.png");
}
WikiUser *wu = WikiUser::RetrieveUser(item->User, item->Site);
if (wu != nullptr)
{
if (wu->IsReported)
{
item->Type = EditType_Reported;
icon = QIcon(":/huggle/pictures/Resources/blob-reported.png");
}
else if (wu->GetWarningLevel() > 0)
{
switch (wu->GetWarningLevel())
{
case 1:
item->Type = EditType_1;
icon = QIcon(":/huggle/pictures/Resources/blob-warn-1.png");
break;
case 2:
item->Type = EditType_2;
icon = QIcon(":/huggle/pictures/Resources/blob-warn-2.png");
break;
case 3:
item->Type = EditType_3;
icon = QIcon(":/huggle/pictures/Resources/blob-warn-3.png");
break;
case 4:
item->Type = EditType_4;
icon = QIcon(":/huggle/pictures/Resources/blob-warn-4.png");
break;
}
}
}
bool selected = this->CurrentEdit->RevID == item->RevID.toInt();
if (selected && x == 0)
IsLatest = true;
item->IsCurrent = true;
if (selected)
this->SelectedRow = x;
QFont font;
font.setItalic(founder);
font.setBold(selected);
QTableWidgetItem *i = new QTableWidgetItem(icon, "");
this->ui->tableWidget->setItem(x, 0, i);
i = new QTableWidgetItem(item->User);
i->setFont(font);
this->ui->tableWidget->setItem(x, 1, i);
i = new QTableWidgetItem(item->Size);
i->setFont(font);
this->ui->tableWidget->setItem(x, 2, i);
i = new QTableWidgetItem(item->Summary);
i->setFont(font);
this->ui->tableWidget->setItem(x, 3, i);
i = new QTableWidgetItem(item->Date);
i->setFont(font);
this->ui->tableWidget->setItem(x, 4, i);
i = new QTableWidgetItem(item->RevID);
i->setFont(font);
this->ui->tableWidget->setItem(x, 5, i);
this->Items.append(item);
x++;
}
this->ui->tableWidget->resizeRowsToContents();
this->query = nullptr;
this->t1->stop();
if (!this->CurrentEdit->NewPage && !Configuration::HuggleConfiguration->ForcedNoEditJump && !IsLatest)
{
if (Configuration::HuggleConfiguration->UserConfig->LastEdit)
{
this->Display(0, Resources::Html_StopFire, true);
return;
}
else
{
QPoint pntr(0, this->pos().y());
if (this->pos().x() > 400)
pntr.setX(this->pos().x() - 200);
else
pntr.setX(this->pos().x() + 100);
// display a tip
QToolTip::showText(pntr, "<b><big>" + _l("historyform-not-latest-tip") + "</big></b>", this);
}
}
if (hcfg->UserConfig->AutomaticallyGroup)
{
// Check if edits made around of this one weren't made by same user
// in case they were we need to display a range of them
QString user = this->CurrentEdit->User->Username;
int RangeStart = this->SelectedRow;
int RangeEnd = this->SelectedRow;
int row = this->SelectedRow;
while (row > 0)
{
if (user != this->ui->tableWidget->item(row - 1, 1)->text())
break;
row--;
}
RangeStart = row;
row = this->SelectedRow;
while (row < (this->ui->tableWidget->rowCount() - 1))
{
if (user != this->ui->tableWidget->item(row + 1, 1)->text())
break;
row++;
}
RangeEnd = row;
if (RangeStart != RangeEnd)
{
QItemSelectionModel *selectionModel = this->ui->tableWidget->selectionModel();
row = RangeStart;
this->IgnoreSelectionChanges = true;
this->ui->tableWidget->clearSelection();
QItemSelection itemSelection = selectionModel->selection();
while (row <= RangeEnd)
{
this->ui->tableWidget->selectRow(row++);
itemSelection.merge(selectionModel->selection(), QItemSelectionModel::Select);
}
selectionModel->clearSelection();
this->IgnoreSelectionChanges = false;
selectionModel->select(itemSelection, QItemSelectionModel::Select);
}
}
this->IgnoreSelectionChanges = false;
MainWindow::HuggleMain->wEditBar->RefreshPage();
}
void
AddIntervalDialog::createClicked()
{
const RideFile *ride = context->currentRide();
if (!ride) {
QMessageBox::critical(this, tr("Select Ride"), tr("No ride selected!"));
return;
}
int maxIntervals = (int) countSpinBox->value();
double windowSizeSecs = (hrsSpinBox->value() * 3600.0
+ minsSpinBox->value() * 60.0
+ secsSpinBox->value());
double windowSizeMeters = (kmsSpinBox->value() * 1000.0
+ msSpinBox->value());
if (windowSizeSecs == 0.0) {
QMessageBox::critical(this, tr("Bad Interval Length"),
tr("Interval length must be greater than zero!"));
return;
}
bool byTime = typeTime->isChecked();
QList<AddedInterval> results;
if (methodBestPower->isChecked()) {
if (peakPowerStandard->isChecked())
findPeakPowerStandard(ride, results);
else
findBests(byTime, ride, (byTime?windowSizeSecs:windowSizeMeters), maxIntervals, results, "");
}
else
findFirsts(byTime, ride, (byTime?windowSizeSecs:windowSizeMeters), maxIntervals, results);
// clear the table
clearResultsTable(resultsTable);
// populate the table
resultsTable->setRowCount(results.size());
int row = 0;
foreach (const AddedInterval &interval, results) {
double secs = interval.start;
double mins = floor(secs / 60);
secs = secs - mins * 60.0;
double hrs = floor(mins / 60);
mins = mins - hrs * 60.0;
// check box
QCheckBox *c = new QCheckBox;
c->setCheckState(Qt::Checked);
resultsTable->setCellWidget(row, 0, c);
// start time
QString start = "%1:%2:%3";
start = start.arg(hrs, 0, 'f', 0);
start = start.arg(mins, 2, 'f', 0, QLatin1Char('0'));
start = start.arg(round(secs), 2, 'f', 0, QLatin1Char('0'));
QTableWidgetItem *t = new QTableWidgetItem;
t->setText(start);
t->setFlags(t->flags() & (~Qt::ItemIsEditable));
resultsTable->setItem(row, 1, t);
QTableWidgetItem *n = new QTableWidgetItem;
n->setText(interval.name);
n->setFlags(n->flags() | (Qt::ItemIsEditable));
resultsTable->setItem(row, 2, n);
// hidden columns - start, stop
QString strt = QString("%1").arg(interval.start); // can't use secs as it gets modified
QTableWidgetItem *st = new QTableWidgetItem;
st->setText(strt);
resultsTable->setItem(row, 3, st);
QString stp = QString("%1").arg(interval.stop); // was interval.start+x
QTableWidgetItem *sp = new QTableWidgetItem;
sp->setText(stp);
resultsTable->setItem(row, 4, sp);
row++;
}
void QPhotorec::PartListWidget_updateUI()
{
list_part_t *element;
PartListWidget->setRowCount(0);
PartListWidget->setSortingEnabled(false);
for(element=list_part; element!=NULL; element=element->next)
{
const partition_t *partition=element->part;
if(partition->status!=STATUS_EXT_IN_EXT)
{
const arch_fnct_t *arch=partition->arch;
const int currentRow = PartListWidget->rowCount();
PartListWidget->setRowCount(currentRow + 1);
if(partition->order==NO_ORDER)
{
QTableWidgetItem *item = new QTableWidgetItem();
item->setData(0, "");
PartListWidget->setItem(currentRow, 0, item);
}
else
{
QTableWidgetItem *item = new QTableWidgetItem();
item->setData(0, partition->order);
PartListWidget->setItem(currentRow, 0, item);
}
{
QTableWidgetItem *item=new QTableWidgetItem(QString(get_partition_status(partition)));
item->setTextAlignment(Qt::AlignHCenter| Qt::AlignVCenter);
PartListWidget->setItem(currentRow, 1, item);
}
if(arch->get_partition_typename(partition)!=NULL)
PartListWidget->setItem(currentRow, 2, new QTableWidgetItem(QString(arch->get_partition_typename(partition))));
else if(arch->get_part_type)
PartListWidget->setItem(currentRow, 2, new QTableWidgetItem(tr("Sys=") + QString::number(arch->get_part_type(partition))));
else
PartListWidget->setItem(currentRow, 2, new QTableWidgetItem(tr("Unknown")));
if(partition->upart_type>0)
{
QTableWidgetItem *item=new QTableWidgetItem(QString(arch_none.get_partition_typename(partition)));
item->setToolTip(QString(partition->info));
PartListWidget->setItem(currentRow, 3, item);
}
else
{
PartListWidget->setItem(currentRow, 3, new QTableWidgetItem(""));
}
{
char sizeinfo[32];
QTableWidgetItem *item;
size_to_unit(partition->part_size, &sizeinfo[0]);
item=new QTableWidgetItem(QString(sizeinfo));
item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
PartListWidget->setItem(currentRow, 4, item);
/* Select the partition if it's already known */
if(selected_partition == partition)
PartListWidget->setCurrentItem(item);
}
{
QString partname="";
if(partition->partname[0]!='\0')
{
partname.sprintf("[%s]", partition->partname);
}
if(partition->fsname[0]!='\0')
{
QString fsname;
fsname.sprintf(" [%s]", partition->fsname);
partname.append(fsname);
}
PartListWidget->setItem(currentRow, 5, new QTableWidgetItem(partname));
}
}
}
PartListWidget->setSortingEnabled(true);
PartListWidget->sortByColumn(0, Qt::AscendingOrder);
PartListWidget->resizeColumnsToContents();
}
// ******************************************************************************************
// Displays data in the link_pairs_ data structure into a QtTableWidget
// ******************************************************************************************
void DefaultCollisionsWidget::loadCollisionTable()
{
int row = 0;
int progress_counter = 0;
// Show Progress Bar
progress_bar_->setValue(0);
QApplication::processEvents(); // allow the progress bar to be shown
progress_label_->setText("Loading table...");
// Setup Collision Table
collision_table_->setUpdatesEnabled(false); // prevent table from updating until we are completely done
collision_table_->setDisabled(true); // make sure we disable it so that the cellChanged event is not called
collision_table_->clearContents();
// Check if there are no disabled collisions (unprobable?)
if(link_pairs_.empty())
{
collision_table_->setRowCount(1);
QTableWidgetItem* no_collide = new QTableWidgetItem("No Link Pairs Of This Kind");
collision_table_->setItem(0, 0, no_collide);
}
else
{
// The table will be populated, so indicate it on the button
btn_generate_->setText("Regenerate Default Collision Matrix");
}
// Intially set the table to be worst-case scenario of every possible element pair
collision_table_->setRowCount( link_pairs_.size() );
for ( moveit_setup_assistant::LinkPairMap::const_iterator pair_it = link_pairs_.begin();
pair_it != link_pairs_.end();
++pair_it)
{
// Add link pair row if 1) it is disabled from collision checking or 2) the SHOW ALL LINK PAIRS checkbox is checked
if( pair_it->second.disable_check || collision_checkbox_->isChecked() )
{
// Create row elements
QTableWidgetItem* linkA = new QTableWidgetItem( pair_it->first.first.c_str() );
linkA->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
QTableWidgetItem* linkB = new QTableWidgetItem( pair_it->first.second.c_str() );
linkB->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
CheckboxSortWidgetItem* disable_check = new CheckboxSortWidgetItem( );
disable_check->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsSelectable);
if( pair_it->second.disable_check ) // Checked means no collision checking
disable_check->setCheckState(Qt::Checked);
else
disable_check->setCheckState(Qt::Unchecked);
QTableWidgetItem* reason = new QTableWidgetItem( longReasonsToString.at( pair_it->second.reason ) );
reason->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
// Insert row elements into collision table
collision_table_->setItem( row, 0, linkA);
collision_table_->setItem( row, 1, linkB);
collision_table_->setItem( row, 2, disable_check);
collision_table_->setItem( row, 3, reason);
// Increment row count
++row;
}
++progress_counter; // for calculating progress bar
if( progress_counter % 200 == 0 )
{
// Update Progress Bar
progress_bar_->setValue( progress_counter * 100 / link_pairs_.size() );
QApplication::processEvents(); // allow the progress bar to be shown
}
}
// Reduce the table size to only the number of used rows.
collision_table_->setRowCount( row );
// Resize headers. The hiding is a hack so that it resizes correctly
collision_table_->setVisible(false);
collision_table_->resizeColumnToContents(0);
collision_table_->resizeColumnToContents(1);
collision_table_->resizeColumnToContents(2);
collision_table_->resizeColumnToContents(3);
collision_table_->setVisible(true);
collision_table_->setUpdatesEnabled(true); // prevent table from updating until we are completely done
}
void Monitor::updateRow(int tid, void * data){
int i;
int row;
QTableWidgetItem * item;
int64_t oldTimer;
link_task_data_t * task = (link_task_data_t*)data;
int stackUsage;
int heapUsage;
row = -1;
//find the tid if it exists in the table
for(i=0; i < ui->table->rowCount(); i++){
item = ui->table->item(i, THREAD_ID_COL);
if ( item != NULL ){
if ( tid == item->text().toInt() ){
row = i;
break;
}
} else {
row = i;
break;
}
}
if ( task->is_enabled ){
if ( row == -1 ){
row = ui->table->rowCount();
ui->table->insertRow(ui->table->rowCount());
}
} else {
if ( row != -1 ){
ui->table->removeRow(row);
}
return;
}
updateItem(row, NAME_COL, task->name);
if ( task->is_thread ){
updateItem(row, PROCESS_ID_COL, QString::number(task->pid, 10) + " (thread)");
} else {
updateItem(row, PROCESS_ID_COL, QString::number(task->pid, 10));
}
if ( task->tid == 0 ){
updateItem(row, THREAD_ID_COL, QString::number(task->tid, 10) + " (idle)");
updateItem(row, PRIO_COL, "n/a");
} else {
updateItem(row, THREAD_ID_COL, QString::number(task->tid, 10));
updateItem(row, PRIO_COL,
QString::number(task->prio_ceiling, 10) + " (" +
QString::number(task->prio, 10) + ")");
}
stackUsage = (task->mem_loc + task->mem_size) - task->stack_ptr;
if ( task->malloc_loc != 0 ){
heapUsage = task->malloc_loc - task->mem_loc;
} else {
heapUsage = 0;
}
updateItem(row, MEM_COL, QString::number( 100.0 * (stackUsage + heapUsage) / ( task->mem_size)));
updateItem(row, STACK_HEAP_COL, QString::number(task->mem_size) + " ("
+ QString::number(stackUsage, 10) + "/"
+ QString::number(heapUsage, 10) + ")");
item = ui->table->item(row, TASK_TIME_COL);
if ( item != NULL ){
oldTimer = item->text().toLongLong();
} else {
item = NULL;
oldTimer = 0;
}
updateItem(row, TASK_TIME_COL, QString::number(task->timer, 10));
updateItem(row, DELTA_TASK_TIME_COL, QString::number(task->timer - oldTimer, 10));
}
void MainWindow::fill_links() {
QString app_path = QApplication::applicationDirPath();
QString dbase_path = app_path + "/base.bz";
{
QSqlDatabase base = QSqlDatabase::addDatabase("QSQLITE", "fill-links");
base.setDatabaseName(dbase_path);
base.open();
if(base.isOpen() != true){
QMessageBox msgbox;
msgbox.setText("There was a problem with the database");
msgbox.setInformativeText("Due to unknown reason there was a problem with opening the database.\nThe problem accured during initial opening of the database.");
msgbox.exec();
}
else {
// the database is open
// clear the table
ui->tbl_links->clear();
for ( int i = 0; i <= 2; i++ ) {
ui->tbl_links->removeColumn(0);
}
QSqlQuery sql_clear(base);
sql_clear.prepare("SELECT * FROM data WHERE user LIKE '" + vApp->id_user() + "'");
sql_clear.exec();
while ( sql_clear.next() ) {
ui->tbl_links->removeRow(0);
}
// in case we just deleted one row on will be left behind ...
ui->tbl_links->removeRow(0);
// start structuring new table
ui->tbl_links->insertColumn(0);
ui->tbl_links->insertColumn(1);
QTableWidgetItem *naslov0 = new QTableWidgetItem;
QTableWidgetItem *naslov1 = new QTableWidgetItem;
naslov0->setText("ID");
naslov1->setText("Ime povezave");
ui->tbl_links->setHorizontalHeaderItem(0, naslov0);
ui->tbl_links->setHorizontalHeaderItem(1, naslov1);
ui->tbl_links->setColumnWidth(0, 35); // first column is with ID, so it can be short
ui->tbl_links->setColumnWidth(1, 300);
QSqlQuery sql_fill(base);
sql_fill.prepare("SELECT * FROM data WHERE user LIKE '" + vApp->id_user() + "' AND profile LIKE '" + vApp->id_profile() + "' AND campaign LIKE '" + vApp->id_campaign() + "'");
sql_fill.exec();
int row = 0;
while (sql_fill.next()) {
ui->tbl_links->insertRow(row);
ui->tbl_links->setRowHeight(row, 20);
int col = 0;
int i = 0;
QString polja[2] = {"id", "link_name"};
while (col <= 1) {
QTableWidgetItem *celica = new QTableWidgetItem;
celica->setText(sql_fill.value(sql_fill.record().indexOf(polja[i])).toString());
ui->tbl_links->setItem(row, col, celica);
col++;
i++;
}
row++;
}
}
base.close();
}
QSqlDatabase::removeDatabase("fill-links");
}
void MusicLrcSearchTableWidget::createSearchedItems(const QString &songname,
const QString &artistname, const QString &time)
{
int count;
setRowCount(count = m_downLoadManager->getSongIdIndex());
QTableWidgetItem *item = new QTableWidgetItem;
item->setData(MUSIC_CHECK_ROLE, false);
setItem(count - 1, 0, item);
item = new QTableWidgetItem;
item->setText(QFontMetrics(font()).elidedText(songname, Qt::ElideRight, 170));
item->setTextColor(QColor(50, 50, 50));
item->setTextAlignment(Qt::AlignCenter);
item->setToolTip(songname);
setItem(count - 1, 1, item);
item = new QTableWidgetItem;
item->setText(QFontMetrics(font()).elidedText(artistname, Qt::ElideRight, 144));
item->setTextColor(QColor(50, 50, 50));
item->setTextAlignment(Qt::AlignCenter);
item->setToolTip(artistname);
setItem(count - 1, 2, item);
item = new QTableWidgetItem(time);
item->setTextColor(QColor(50, 50, 50));
item->setTextAlignment(Qt::AlignCenter);
setItem(count - 1, 3, item);
item = new QTableWidgetItem;
item->setIcon(QIcon(QString::fromUtf8(":/radio/collect")));
setItem(count - 1, 4, item);
}
void CFontListWindow::showFontListWindow(CMainWindow *parent,const QString title,const QRect pos,
CFontFileList *fontFileList,bool showBadFontFiles)
/* --------------------------------------------------------------------------------------------
DESCRIPTION: Display a window containing the list of available fonts
--------------------------------------------------------------------------------------------
PARAMETERS: parent: Parent window
title: The window title
pos: Position on screen
fontFileList: The list of fonts
showBadFontFiles: true => display the list of incompatible fonts
false => hide the list
--------------------------------------------------------------------------------------------
RETURNS: none
-------------------------------------------------------------------------------------------- */
{
if(m_fontListWindow==NULL) //if the singleton window has not yet been created, create it
{
m_fontListWindow=new CFontListWindow(parent);
m_fontListWindow->setWindowTitle(tr("%1 - Available fonts").arg(title));
//position the window. (it is recommended to use resize & move rather than setGeometry)
m_fontListWindow->resize(pos.width(),pos.height());
m_fontListWindow->move(pos.left(),pos.top());
}
m_fontListWindow->show();
//make window the active window if it is already shown
m_fontListWindow->raise();
m_fontListWindow->activateWindow();
m_fontListWindow->m_tableGoodFonts->clearContents();
m_fontListWindow->m_tableGoodFonts->setRowCount(0);
m_fontListWindow->m_tableBadFonts->clearContents();
m_fontListWindow->m_tableBadFonts->setRowCount(0);
QTableWidgetItem *tableItem;
for(int i=0; i< fontFileList->count(); i++) //fill the table with the list of available fonts
{
CFontFileInfo *finfo=fontFileList->at(i);
if(finfo!=0)
{
int row=m_fontListWindow->m_tableGoodFonts->rowCount(); //add a row to the end of the table
m_fontListWindow->m_tableGoodFonts->insertRow(row);
//add an item containing the font name to the first column in the row
tableItem=new QTableWidgetItem(finfo->fontName());
tableItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
m_fontListWindow->m_tableGoodFonts->setItem(row,0,tableItem);
//add an item containing available code pages to the next column
QString codePages;
finfo->availableCodePages(codePages);
tableItem=new QTableWidgetItem(codePages);
tableItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
m_fontListWindow->m_tableGoodFonts->setItem(row,1,tableItem);
//add an item containing the file name to the next column
tableItem=new QTableWidgetItem(finfo->fileName());
tableItem->setFlags(Qt::NoItemFlags);
m_fontListWindow->m_tableGoodFonts->setItem(row, 2, tableItem);
m_fontListWindow->m_tableGoodFonts->resizeRowToContents(row);
}
}
QStringList *badfiles=fontFileList->badFileList(); //get the list of incompatible fonts
for(int i=0;i<badfiles->count();i++) //and fill the table with the list
{
QString fileName=badfiles->at(i);
if(fileName.size()>0)
{
int row=m_fontListWindow->m_tableBadFonts->rowCount();
m_fontListWindow->m_tableBadFonts->insertRow(row);
tableItem=new QTableWidgetItem(fileName);
tableItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
m_fontListWindow->m_tableBadFonts->setItem(row, 0, tableItem);
}
}
if(showBadFontFiles==true)
{
m_fontListWindow->m_tableBadFonts->show();
m_fontListWindow->m_lblBadFonts->show();
}
else
{
m_fontListWindow->m_tableBadFonts->hide();
m_fontListWindow->m_lblBadFonts->hide();
}
}
SeeStats::SeeStats(Session *session, QWidget *parent) :
QWidget(parent),
ui(new Ui::SeeStats)
{
ui->setupUi(this);
this->showMaximized();
ostringstream s;
s << "SELECT Student.id AS id, Student.name AS name, Student.directory AS path, COUNT(Face.id) AS caras, "
"SessionStudent.'column' AS columna, SessionStudent.'row' AS fila\n"
"FROM Student, Face, SessionStudent\n"
"WHERE Student.id = Face.id_student and Face.id_session =" << session->getId() <<
" and SessionStudent.id_session =" << session->getId() << " and SessionStudent.id_student = Student.id\n" <<
"GROUP BY Student.id;";
cout << s.str() << endl;
QSqlQuery query = QSqlQuery(QString(s.str().c_str()));
ui->tableWidget->setColumnCount(5);
int i = 1;
ui->tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem("Foto"));
ui->tableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem("Nombre"));
ui->tableWidget->setHorizontalHeaderItem(2, new QTableWidgetItem("Número de caras en esta sesión"));
ui->tableWidget->setHorizontalHeaderItem(3, new QTableWidgetItem("Fila"));
ui->tableWidget->setHorizontalHeaderItem(4, new QTableWidgetItem("Columna"));
ui->tableWidget->horizontalHeader()->setStretchLastSection(true);
while(query.next()){
cout << "ENTRA" << endl;
string name = query.value("name").toString().toStdString();
string path = query.value("path").toString().toStdString();
QString pathImage = QString(path.c_str()) + "/0.jpg";
QImage* image = new QImage();
ui->tableWidget->setRowCount(i);
if(!image->load(pathImage)) cout << "ERROR LOADING" << endl;
else{
QTableWidgetItem * itm = new QTableWidgetItem;
*image = image->scaledToHeight(50);
itm->setData(Qt::DecorationRole, QPixmap::fromImage(*image));
itm->setFlags(itm->flags() ^ Qt::ItemIsEditable);
ui->tableWidget->setItem(i - 1, 0, itm);
QTableWidgetItem *itm2 = new QTableWidgetItem;
itm2->setData(Qt::DisplayRole, name.c_str());
ui->tableWidget->setItem(i - 1, 1, itm2);
QTableWidgetItem* itm3 = new QTableWidgetItem;
itm3->setData(Qt::DisplayRole, query.value("caras").toString());
ui->tableWidget->setItem(i - 1, 2, itm3);
QTableWidgetItem* itm4 = new QTableWidgetItem;
itm4->setData(Qt::DisplayRole, query.value("fila").toString());
ui->tableWidget->setItem(i - 1, 3, itm4);
QTableWidgetItem* itm5 = new QTableWidgetItem;
itm5->setData(Qt::DisplayRole, query.value("columna").toString());
ui->tableWidget->setItem(i - 1, 4, itm5);
}
i++;
}
ui->tableWidget->resizeColumnsToContents();
ui->tableWidget->resizeRowsToContents();
}
void Customers::getAllCustomerData()
{
DbMysql* d = DbMysql::getInstance();
/*
QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL");
db.setHostName("localhost");
db.setDatabaseName("testQt");
db.setUserName("root");
db.setPort(3306);
db.setPassword("");
*/
if (!d->getConnection().open()){
qDebug() << "Failed to connect to root mysql admin";
qDebug() << d->getConnection().lastError().text();
}
else {
/*
DbMysql* db1 = DbMysql::getInstance();
if(!db1->getDb().open()){
return;
}
else {
*/
QSqlQuery query( "SELECT * FROM customers order by customer_id desc;",d->getConnection() );
if( !query.isActive() )
{
QMessageBox msgBox;
msgBox.critical(this,"Error","Failed to execute query.");
qDebug()<<"Failed to execute query. select customers";
qDebug()<<query.lastError().text();
return;
}
else{
int row = 0;
ui->customersDetailsTable->setRowCount(query.size());
while( query.next() )
{
//QStringList ss = line.split('\t');
//if(ui->customersDetailsTable->rowCount() < row + 1)
//if(ui->tableWidget->columnCount() < ss.size())
// ui->tableWidget->setColumnCount( ss.size() );
int columnSize = ui->customersDetailsTable->columnCount();
//qDebug()<<"Column Size:"<<ui->customersDetailsTable->columnCount();
for( int column = 0; column < columnSize; column++)
{
QTableWidgetItem *newItem = new QTableWidgetItem();
newItem->setText(query.value(column).toString());
//qDebug()<<"Data:"<<query.value(column).toString();
ui->customersDetailsTable->setItem(row, column, newItem);
}
row++;
//int fff = query.value( 0 ).toInt();
}
//ui->customersDetailsTable->resizeColumnsToContents();
ui->customersDetailsTable->horizontalHeader()->setHighlightSections(false);
//ui->customersDetailsTable->horizontalHeader()->setStyleSheet("QHeaderView::section { background-color:#0B2161;color:#fff; }");
}
d->getConnection().close();
//}
}
}
void MPConfig::songChanged(int flags)
{
// Is it simply a midi controller value adjustment? Forget it.
if (flags == SC_MIDI_CONTROLLER)
return;
// Get currently selected index...
int no = -1;
QTableWidgetItem* sitem = mdevView->currentItem();
if (sitem)
{
QString id = sitem->tableWidget()->item(sitem->row(), DEVCOL_NO)->text();
no = atoi(id.toLatin1().constData()) - 1;
if (no < 0 || no >= kMaxMidiPorts)
no = -1;
}
sitem = 0;
for (int i = kMaxMidiPorts - 1; i >= 0; --i)
{
mdevView->blockSignals(true); // otherwise itemChanged() is triggered and bad things happen.
MidiPort* port = &midiPorts[i];
MidiDevice* dev = port->device();
QString s;
s.setNum(i + 1);
QTableWidgetItem* itemno = mdevView->item(i, DEVCOL_NO);
QTableWidgetItem* itemstate = mdevView->item(i, DEVCOL_STATE);
itemstate->setText(port->state());
QTableWidgetItem* iteminstr = mdevView->item(i, DEVCOL_INSTR);
QString instrumentName = port->instrument() ? port->instrument()->iname() : tr("<unknown>");
iteminstr->setText(instrumentName);
iteminstr->setToolTip(instrumentName);
QTableWidgetItem* itemname = mdevView->item(i, DEVCOL_NAME);
QTableWidgetItem* itemgui = mdevView->item(i, DEVCOL_GUI);
QTableWidgetItem* itemfb = mdevView->item(i, DEVCOL_CACHE_NRPN);
QTableWidgetItem* itemrec = mdevView->item(i, DEVCOL_REC);
QTableWidgetItem* itemplay = mdevView->item(i, DEVCOL_PLAY);
QTableWidgetItem* itemout = mdevView->item(i, DEVCOL_OUTROUTES);
QTableWidgetItem* itemin = mdevView->item(i, DEVCOL_INROUTES);
QTableWidgetItem* itemdefin = mdevView->item(i, DEVCOL_DEF_IN_CHANS);
itemdefin->setText(bitmap2String(port->defaultInChannels()));
QTableWidgetItem* itemdefout = mdevView->item(i, DEVCOL_DEF_OUT_CHANS);
itemdefout->setText(bitmap2String(port->defaultOutChannels()));
mdevView->blockSignals(false);
if (dev)
{
itemname->setText(dev->name());
itemname->setToolTip(dev->name());
// Is it a Jack midi device? Allow renaming.
//if(dynamic_cast<MidiJackDevice*>(dev))
if (dev->deviceType() == MidiDevice::JACK_MIDI)
itemname->setFlags(Qt::ItemIsEditable | Qt::ItemIsEnabled);
if (dev->rwFlags() & 0x2)
{
itemrec->setIcon(dev->openFlags() & 2 ? QIcon(*dotIcon) : QIcon(*dothIcon));
}
else
{
itemrec->setIcon(QIcon(QPixmap()));
}
if (dev->rwFlags() & 0x1)
{
itemplay->setIcon(dev->openFlags() & 1 ? QIcon(*dotIcon) : QIcon(*dothIcon));
}
else
itemplay->setIcon(QIcon(QPixmap()));
itemfb->setIcon(dev->cacheNRPN() ? QIcon(*dotIcon) : QIcon(*dothIcon));
}
else
{
itemname->setText(tr("<none>"));
itemname->setToolTip("");
itemgui->setIcon(QIcon(*dothIcon));
itemrec->setIcon(QIcon(QPixmap()));
itemplay->setIcon(QIcon(QPixmap()));
itemfb->setIcon(QIcon(QPixmap()));
}
// falkTX, we don't want this in the connections manager
//if (port->hasGui())
//{
// itemgui->setIcon(port->guiVisible() ? QIcon(*dotIcon) : QIcon(*dothIcon));
//}
//else
//{
itemgui->setIcon(QIcon(QPixmap()));
//}
iteminstr->setIcon(QIcon(*buttondownIcon));
itemname->setIcon(QIcon(*buttondownIcon));
//if(dev && dynamic_cast<MidiJackDevice*>(dev))
if (dev && dev->deviceType() == MidiDevice::JACK_MIDI)
{
//item->setPixmap(DEVCOL_ROUTES, *buttondownIcon);
//item->setText(DEVCOL_ROUTES, tr("routes"));
// p3.3.55
if (dev->rwFlags() & 1)
//if(dev->openFlags() & 1)
{
itemout->setIcon(QIcon(*buttondownIcon));
if (port->device() && !port->device()->outRoutes()->empty())
{
RouteList* list = port->device()->outRoutes();
if (!list->empty())
{
iRoute r = list->begin();
itemout->setText(r->name());
}
}
else
{
itemout->setText(tr("out"));
}
//if (dev->openFlags() & 1)
// itemout->setText(tr("out"));
}
if (dev->rwFlags() & 2)
//if(dev->openFlags() & 2)
{
itemin->setIcon(QIcon(*buttondownIcon));
if (dev->openFlags() & 2)
itemin->setText(tr("in"));
}
}
if (i == no) sitem = itemno;
}
if (sitem)
{
mdevView->setCurrentItem(sitem);
}
}
void FlarmAliasList::slot_Ok()
{
if( list->rowCount() != 0 )
{
// Check data for consistency. Empty entries are not accepted.
for( int i = 0; i < list->rowCount(); i++ )
{
for( int j = 0; j < 2; j++ )
{
if( list->item( i, j )->text().trimmed().isEmpty() )
{
QMessageBox mb( QMessageBox::Warning,
tr( "Missing Entry" ),
tr( "Please fill out all fields!" ),
QMessageBox::Ok,
this );
#ifdef ANDROID
mb.show();
QPoint pos = mapToGlobal(QPoint( width()/2 - mb.width()/2,
height()/2 - mb.height()/2 ));
mb.move( pos );
#endif
mb.exec();
return;
}
}
}
}
aliasHash.clear(); // Clear alias hash
// Save all to alias hash
for( int i = 0; i < list->rowCount(); i++ )
{
// Alias names are limited to MaxAliasLength characters
aliasHash.insert( list->item( i, 0 )->text().trimmed(),
list->item( i, 1 )->text().trimmed().left(MaxAliasLength) );
}
saveAliasData(); // Save data into file
// Check, if only one row is selected. In this case this item is set as
// the selected Flarm identifier. No row selection will reset the current
// selected Flarm identifier.
QList<QTableWidgetItem *> items = list->selectedItems();
if( items.size() >= 0 && items.size() <= 2 )
{
QString selectedObject = "";
if( items.size() > 0 )
{
QTableWidgetItem *item = items.at(0);
selectedObject = item->text().trimmed();
}
// Report new selection to FlarmListView and FlarmDisplay
emit newObjectSelection( selectedObject );
}
slot_Close();
}
LapTimeComparisonDialog::LapTimeComparisonDialog(QWidget *parent) :
QDialog(parent, Qt::Window), ui(new Ui::LapTimeComparisonDialog), eventData(EventData::getInstance()), thumbnailsSize(150)
{
ui->setupUi(this);
comboBox[0] = ui->comboBox1;
comboBox[1] = ui->comboBox2;
comboBox[2] = ui->comboBox3;
comboBox[3] = ui->comboBox4;
loadDriversList();
lapCompChart = new LapCompChart(this);
connect(ui->comboBox1, SIGNAL(currentIndexChanged(int)), this, SLOT(comboBoxValueChanged(int)));
connect(ui->comboBox2, SIGNAL(currentIndexChanged(int)), this, SLOT(comboBoxValueChanged(int)));
connect(ui->comboBox3, SIGNAL(currentIndexChanged(int)), this, SLOT(comboBoxValueChanged(int)));
connect(ui->comboBox4, SIGNAL(currentIndexChanged(int)), this, SLOT(comboBoxValueChanged(int)));
ui->tableWidget->setItemDelegate(new LTItemDelegate(this));
ui->tableWidget->setColumnWidth(0, 30);
ui->tableWidget->setColumnWidth(1, 150);
ui->tableWidget->setColumnWidth(2, 150);
ui->tableWidget->setColumnWidth(3, 150);
ui->tableWidget->setColumnWidth(4, 150);
ui->chartsTableWidget->setColumnWidth(0, 170);
ui->chartsTableWidget->setColumnWidth(1, 170);
ui->chartsTableWidget->setColumnWidth(2, 170);
ui->chartsTableWidget->setColumnWidth(3, 170);
ui->chartsTableWidget->insertRow(0);
ui->chartsTableWidget->setRowHeight(0, 20);
ui->chartsTableWidget->insertRow(1);
ui->chartsTableWidget->setRowHeight(1, 50);
QTableWidgetItem *item;
for (int j = 0; j < 4; ++j)
{
item = new QTableWidgetItem();
item->setFlags(Qt::NoItemFlags);
item->setTextAlignment(Qt::AlignCenter);
ui->chartsTableWidget->setItem(0, j, item);
}
ui->chartsTableWidget->insertRow(2);
ui->chartsTableWidget->setCellWidget(2, 0, lapCompChart);
ui->chartsTableWidget->setSpan(2, 0, 1, 4);
ui->chartsTableWidget->setRowHeight(2, 500);
ui->tableWidget->insertRow(0);
item = new QTableWidgetItem("Lap");
item->setFlags(Qt::NoItemFlags);
item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
item->setTextColor(ColorsManager::getInstance().getColor(LTPackets::DEFAULT));
ui->tableWidget->setItem(0, 0, item);
QLabel *lab = new QLabel();
ui->tableWidget->setCellWidget(0, 1, lab);
lab->setAlignment(Qt::AlignCenter);
lab = new QLabel();
ui->tableWidget->setCellWidget(0, 2, lab);
lab->setAlignment(Qt::AlignCenter);
lab = new QLabel();
ui->tableWidget->setCellWidget(0, 3, lab);
lab->setAlignment(Qt::AlignCenter);
lab = new QLabel();
ui->tableWidget->setCellWidget(0, 4, lab);
lab->setAlignment(Qt::AlignCenter);
ui->tableWidget->setRowHeight(0, 50);
}
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();
}
}
void QgsVectorLayerSaveAsDialog::on_mFormatComboBox_currentIndexChanged( int idx )
{
Q_UNUSED( idx );
browseFilename->setEnabled( true );
leFilename->setEnabled( true );
if ( format() == "KML" )
{
mEncodingComboBox->setCurrentIndex( mEncodingComboBox->findText( "UTF-8" ) );
mEncodingComboBox->setDisabled( true );
mAttributesSelection->setChecked( true );
}
else if ( format() == "DXF" )
{
mAttributesSelection->setChecked( true );
mAttributesSelection->setDisabled( true );
}
else
{
mEncodingComboBox->setEnabled( true );
mAttributesSelection->setEnabled( true );
}
if ( mLayer )
{
mAttributeTable->setRowCount( mLayer->fields().count() );
bool foundFieldThatCanBeExportedAsDisplayedValue = false;
for ( int i = 0; i < mLayer->fields().size(); ++i )
{
QgsEditorWidgetFactory *factory;
if ( mLayer->editFormConfig()->widgetType( i ) != "TextEdit" &&
( factory = QgsEditorWidgetRegistry::instance()->factory( mLayer->editFormConfig()->widgetType( i ) ) ) )
{
foundFieldThatCanBeExportedAsDisplayedValue = true;
break;
}
}
if ( foundFieldThatCanBeExportedAsDisplayedValue )
{
mAttributeTable->setColumnCount( 3 );
mAttributeTable->setHorizontalHeaderLabels( QStringList() << tr( "Name" ) << tr( "Type" ) << tr( "Replace with displayed values" ) );
}
else
{
mAttributeTable->setColumnCount( 2 );
mAttributeTable->setHorizontalHeaderLabels( QStringList() << tr( "Name" ) << tr( "Type" ) );
mReplaceRawFieldValues->setVisible( false );
}
mAttributeTableItemChangedSlotEnabled = false;
for ( int i = 0; i < mLayer->fields().size(); ++i )
{
const QgsField &fld = mLayer->fields().at( i );
Qt::ItemFlags flags = mLayer->providerType() != "oracle" || !fld.typeName().contains( "SDO_GEOMETRY" ) ? Qt::ItemIsEnabled : Qt::NoItemFlags;
QTableWidgetItem *item;
item = new QTableWidgetItem( fld.name() );
item->setFlags( flags | Qt::ItemIsUserCheckable );
item->setCheckState( Qt::Unchecked );
mAttributeTable->setItem( i, COLUMN_IDX_NAME, item );
item = new QTableWidgetItem( fld.typeName() );
item->setFlags( flags );
mAttributeTable->setItem( i, COLUMN_IDX_TYPE, item );
if ( foundFieldThatCanBeExportedAsDisplayedValue )
{
QgsEditorWidgetFactory *factory;
if ( mLayer->editFormConfig()->widgetType( i ) != "TextEdit" &&
( factory = QgsEditorWidgetRegistry::instance()->factory( mLayer->editFormConfig()->widgetType( i ) ) ) )
{
item = new QTableWidgetItem( tr( "Use %1" ).arg( factory->name() ) );
item->setFlags( Qt::ItemIsUserCheckable );
item->setCheckState( Qt::Unchecked );
mAttributeTable->setItem( i, COLUMN_IDX_EXPORT_AS_DISPLAYED_VALUE, item );
}
else
{
item = new QTableWidgetItem();
item->setFlags( Qt::NoItemFlags );
mAttributeTable->setItem( i, COLUMN_IDX_EXPORT_AS_DISPLAYED_VALUE, item );
}
}
}
mAttributeTableItemChangedSlotEnabled = true;
mReplaceRawFieldValues->setEnabled( false );
mAttributeTable->resizeColumnsToContents();
}
QgsVectorFileWriter::MetaData driverMetaData;
while ( mDatasourceOptionsGroupBox->layout()->count() )
{
QLayoutItem* item = mDatasourceOptionsGroupBox->layout()->takeAt( 0 );
delete item->widget();
delete item;
}
while ( mLayerOptionsGroupBox->layout()->count() )
{
QLayoutItem* item = mLayerOptionsGroupBox->layout()->takeAt( 0 );
delete item->widget();
delete item;
}
// workaround so the Q_FOREACH macro does not get confused by the ','
typedef QPair<QLabel*, QWidget*> LabelControlPair;
if ( QgsVectorFileWriter::driverMetadata( format(), driverMetaData ) )
{
if ( driverMetaData.driverOptions.size() != 0 )
{
mDatasourceOptionsGroupBox->setVisible( true );
QList<QPair<QLabel*, QWidget*> > controls = createControls( driverMetaData.driverOptions );
QFormLayout* datasourceLayout = dynamic_cast<QFormLayout*>( mDatasourceOptionsGroupBox->layout() );
Q_FOREACH ( LabelControlPair control, controls )
{
datasourceLayout->addRow( control.first, control.second );
}
}
//Slot that handles the date selection in the view.
void MonthView::slot_dateSelected(int row, int column)
{
QTableWidgetItem *item = ui->tblDates->item(row,column);
emit(DateChanged(QDate::fromString(item->whatsThis())));
}
void QgsDwgImportDialog::on_pbLoadDatabase_clicked()
{
if ( !QFileInfo( leDatabase->text() ).exists() )
return;
CursorOverride waitCursor;
bool lblVisible = false;
QScopedPointer<QgsVectorLayer> d( new QgsVectorLayer( QString( "%1|layername=drawing" ).arg( leDatabase->text() ), "layers", "ogr", false ) );
if ( d && d->isValid() )
{
int idxPath = d->fields().lookupField( "path" );
int idxLastModified = d->fields().lookupField( "lastmodified" );
int idxCrs = d->fields().lookupField( "crs" );
QgsFeature f;
if ( d->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( QgsAttributeList() << idxPath << idxLastModified << idxCrs ) ).nextFeature( f ) )
{
leDrawing->setText( f.attribute( idxPath ).toString() );
QgsCoordinateReferenceSystem crs( f.attribute( idxCrs ).toInt(), QgsCoordinateReferenceSystem::InternalCrsId );
mCrsSelector->setCrs( crs );
mCrsSelector->setLayerCrs( crs );
QFileInfo fi( leDrawing->text() );
if ( fi.exists() )
{
if ( fi.lastModified() > f.attribute( idxLastModified ).toDateTime() )
{
lblMessage->setText( tr( "Drawing file was meanwhile updated (%1 > %2)." ).arg( fi.lastModified().toString(), f.attribute( idxLastModified ).toDateTime().toString() ) );
lblVisible = true;
}
}
else
{
lblMessage->setText( tr( "Drawing file unavailable." ) );
lblVisible = true;
}
}
}
lblMessage->setVisible( lblVisible );
QScopedPointer<QgsVectorLayer> l( new QgsVectorLayer( QString( "%1|layername=layers" ).arg( leDatabase->text() ), "layers", "ogr", false ) );
if ( l && l->isValid() )
{
int idxName = l->fields().lookupField( "name" );
int idxColor = l->fields().lookupField( "ocolor" );
int idxFlags = l->fields().lookupField( "flags" );
QgsDebugMsg( QString( "idxName:%1 idxColor:%2 idxFlags:%3" ).arg( idxName ).arg( idxColor ).arg( idxFlags ) );
QgsFeatureIterator fit = l->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( QgsAttributeList() << idxName << idxColor << idxFlags ) );
QgsFeature f;
mLayers->setRowCount( 0 );
while ( fit.nextFeature( f ) )
{
int row = mLayers->rowCount();
mLayers->setRowCount( row + 1 );
QgsDebugMsg( QString( "name:%1 color:%2 flags:%3" ).arg( f.attribute( idxName ).toString() ).arg( f.attribute( idxColor ).toInt() ).arg( f.attribute( idxFlags ).toString(), 0, 16 ) );
QTableWidgetItem *item;
item = new QTableWidgetItem( f.attribute( idxName ).toString() );
item->setFlags( Qt::ItemIsUserCheckable | Qt::ItemIsEnabled );
item->setCheckState( Qt::Checked );
mLayers->setItem( row, 0, item );
item = new QTableWidgetItem();
item->setFlags( Qt::ItemIsUserCheckable | Qt::ItemIsEnabled );
item->setCheckState(( f.attribute( idxColor ).toInt() >= 0 && ( f.attribute( idxFlags ).toInt() & 1 ) == 0 ) ? Qt::Checked : Qt::Unchecked );
mLayers->setItem( row, 1, item );
}
mLayers->resizeColumnsToContents();
buttonBox->button( QDialogButtonBox::Ok )->setEnabled( mLayers->rowCount() > 0 && !leLayerGroup->text().isEmpty() );
}
else
{
QgisApp::instance()->messageBar()->pushMessage( tr( "Could not open layer list" ), QgsMessageBar::CRITICAL, 4 );
}
}
/***********************************************************************
* Wywołuje modalne okienko wyboru pliku.
* Trzeba wskazać poprawny plik z sygnałem EKG,
* możliwy do wczytania przez bibliotekę WFDB,
* czyli jeden z trzech plików: .dat .hea .atr
* o współnym przedrostku zgodnym z jakimś id wewnątrz.
* Plik zostanie wczytany i wyświetlone zostaną dane
* z obu kanałów.
* Zaznaczenie fragmenu wykresu myszą przybliża go.
* Można wtedy przewijać wykres środkowym przyciskiem myszy.
* Oddala się prawym, ew. z wciśniętym klawiszem Ctrl (jest bug).
***********************************************************************/
void ECGanalyzer::on_actionWczytaj_plik_z_sygnalem_triggered()
{
QString fileName = QFileDialog::getOpenFileName(this);
if(!fileName.isNull() && !fileName.isEmpty())
{
if(!_ECGcontroller.readFile(fileName.toStdString()) ) // why?
{
QMessageBox::critical(NULL, "Błąd", "Nie udało się wczytać sygnału");
return;//throw new exception("Nie udało się wczytać sygnału");
}
_ECGcontroller.runECGBaseline();
// _ECGcontroller.runRPeaks();
ui.rawPlotWidget->setSignal(&(_ECGcontroller.raw_signal), &(_ECGcontroller.ecg_info), &(_ECGcontroller.r_peaks_data));
QTableWidgetItem *fileName = new QTableWidgetItem();
fileName->setText(QString::fromStdString(_ECGcontroller.ecg_info.channel_one.filename) );
ui.tableWidgetSignalInfo->setItem(0, 0, fileName);
QTableWidgetItem *description = new QTableWidgetItem();
description->setText(QString::fromStdString(_ECGcontroller.ecg_info.channel_one.description) );
ui.tableWidgetSignalInfo->setItem(1, 0, description);
QTableWidgetItem *signalResolution = new QTableWidgetItem();
signalResolution->setText(QString().sprintf("%d bits", _ECGcontroller.ecg_info.channel_one.signal_resolution) );
ui.tableWidgetSignalInfo->setItem(2, 0, signalResolution);
QTableWidgetItem *zeroSignal = new QTableWidgetItem();
zeroSignal->setText(QString().sprintf("%d", _ECGcontroller.ecg_info.channel_one.zero_signal) );
ui.tableWidgetSignalInfo->setItem(3, 0, zeroSignal);
QTableWidgetItem *gain = new QTableWidgetItem();
gain->setText(QString().sprintf("%f", _ECGcontroller.ecg_info.channel_one.gain) );
ui.tableWidgetSignalInfo->setItem(4, 0, gain);
QTableWidgetItem *numberOfSamples = new QTableWidgetItem();
numberOfSamples->setText(QString().sprintf("%d", _ECGcontroller.ecg_info.channel_one.nr_samples) );
ui.tableWidgetSignalInfo->setItem(5, 0, numberOfSamples);
QTableWidgetItem *frequency = new QTableWidgetItem();
frequency->setText(QString().sprintf("%d Hz", _ECGcontroller.ecg_info.channel_one.frequecy) );
ui.tableWidgetSignalInfo->setItem(6, 0, frequency);
QTableWidgetItem *range = new QTableWidgetItem();
range->setText(QString().sprintf("%d mV", _ECGcontroller.ecg_info.channel_one.range) );
ui.tableWidgetSignalInfo->setItem(7, 0, range);
/*
_ECGcontroller.runHRT();
QVBoxLayout *plotHARTLayout = new QVBoxLayout;
PlotHRT *plotHRT = new PlotHRT(this);
plotHARTLayout->addWidget(plotHRT);
plotHRT->setData(_ECGcontroller.hrt_data);
ui.groupBox->setLayout(plotHARTLayout);*/
ECGHRV2 hrv2_data;
// ...
QVBoxLayout *plotHRVTriangleLayout = new QVBoxLayout;
PlotHRVTriangle *plotHRVTriangle = new PlotHRVTriangle(this);
plotHRVTriangleLayout->addWidget(plotHRVTriangle);
//plotHRVTriangle->setData(hrv2_data);
ui.tab_2->setLayout(plotHRVTriangleLayout);
QVBoxLayout *plotPoincareLayout = new QVBoxLayout;
PlotPoincare *plotPoincare = new PlotPoincare(this);
plotPoincareLayout->addWidget(plotPoincare);
//plotPoincare->setData(hrv2_data);
ui.tab_3->setLayout(plotPoincareLayout);
ui.actionPrzeprowadzPonownieAnalizeSygnalu->setEnabled(true);
}
}
void VibrationWidget::setMolecule(Molecule *molecule)
{
// update table
ui.vibrationTable->clearContents();
if (molecule == 0){
ui.vibrationTable->setRowCount(0);
ui.vibrationTable->horizontalHeader()->hide();
return;
}
m_molecule = molecule;
OBMol obmol = molecule->OBMol();
m_vibrations = static_cast<OBVibrationData*>(obmol.GetData(OBGenericDataType::VibrationData));
if (!m_vibrations) {
ui.vibrationTable->setRowCount(0);
ui.vibrationTable->horizontalHeader()->hide();
//ui.exportButton->setEnabled(false);
return;
}
ui.vibrationTable->horizontalHeader()->show();
ui.vibrationTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
// OK, we have valid vibrations, so add them to the table
vector<double> frequencies = m_vibrations->GetFrequencies();
vector<double> intensities = m_vibrations->GetIntensities();
m_frequencies = frequencies;
m_intensities = intensities;
vector<double> raman_activities = m_vibrations->GetRamanActivities();
if (raman_activities.size() == 0) {
//resize(274, height());
ui.vibrationTable->setColumnCount(2);
if(parentWidget())
parentWidget()->setMinimumWidth(274);
}
else {
//resize(310, height());
ui.vibrationTable->setColumnCount(3);
ui.vibrationTable->setHorizontalHeaderItem(2,
new QTableWidgetItem("Activity"));
if(parentWidget())
parentWidget()->setMinimumWidth(310);
}
// Generate an index vector to map sorted indicies to the old indices
m_indexMap->clear();
for (uint i = 0; i < frequencies.size(); i++)
m_indexMap->push_back(i);
// Setup progress dialog, just in case it takes longer than 2 seconds
QProgressDialog prog(tr("Sorting %1 vibrations by frequency...")
.arg(frequencies.size()), "", 0, frequencies.size());
prog.setWindowModality(Qt::WindowModal);
prog.setMinimumDuration(2000);
prog.setCancelButton(0);
// Simple selection sort
double tmp;
int tmp_int;
for (uint i = 0; i < frequencies.size(); i++) {
for (uint j = i; j < frequencies.size(); j++) {
if (i == j)
continue; // Save a bit of time...
if (frequencies.at(j) < frequencies.at(i)) {
tmp = frequencies.at(j);
frequencies.at(j) = frequencies.at(i);
frequencies.at(i) = tmp;
tmp = intensities.at(j);
intensities.at(j) = intensities.at(i);
intensities.at(i) = tmp;
tmp_int = m_indexMap->at(j);
m_indexMap->at(j) = m_indexMap->at(i);
m_indexMap->at(i) = tmp_int;
}
}
// Update progress bar
prog.setValue(i);
}
ui.vibrationTable->setRowCount(frequencies.size());
QString format("%1");
for (unsigned int row = 0; row < frequencies.size(); ++row) {
QTableWidgetItem *newFreq = new QTableWidgetItem(format.arg(frequencies[row], 0, 'f', 2));
newFreq->setTextAlignment(Qt::AlignRight|Qt::AlignVCenter);
// Some codes don't provide intensity data. Display "-" in place of intensities.
QTableWidgetItem *newInten;
if (row >= intensities.size()) {
newInten = new QTableWidgetItem("-");
}
else {
newInten = new QTableWidgetItem(format.arg(intensities[row], 0, 'f', 3));
}
newInten->setTextAlignment(Qt::AlignRight|Qt::AlignVCenter);
ui.vibrationTable->setItem(row, 0, newFreq);
ui.vibrationTable->setItem(row, 1, newInten);
if (raman_activities.size() != 0) {
QTableWidgetItem *newRaman;
if (row >= raman_activities.size()) {
newRaman = new QTableWidgetItem("-");
}
else {
newRaman = new QTableWidgetItem(format.arg(raman_activities[row], 0,
'f', 3));
}
newRaman->setTextAlignment(Qt::AlignRight|Qt::AlignVCenter);
ui.vibrationTable->setItem(row, 2, newRaman);
}
}
// enable export button
//ui.exportButton->setEnabled(true);
}
void MainWindow::on_pushButton_pressed()
{
m_gbFinished = true;
int score=0;
for(int i=0;i<m_data.getSize();i++)
{
if(m_data[i].getChoosen()==m_data[i].getRightAnswer())
{
score++;
}
}
ui->action_4->setDisabled(false);
ui->action_2->setDisabled(true);
this->repaint();
ui->totalCount->setVisible(true);
QString total;
int m_Total;
if(m_data.getSize()<10)
{
m_Total = m_data.getSize();
}
else
{
m_Total = 10;
}
total.setNum(static_cast<double>(m_Total));
ui->totalCount->setText(total);
instance[instance.GetSize()-1].SetScore(score);
ui->radioButton->setVisible(false);
ui->radioButton_2->setVisible(false);
ui->radioButton_3->setVisible(false);
ui->radioButton_4->setVisible(false);
ui->choosen->setVisible(false);
ui->label->setVisible(false);
ui->label_2->setVisible(false);
ui->label_3->setVisible(false);
ui->pushButton_2->setVisible(false);
ui->pushButton_3->setVisible(false);
ui->pushButton->setVisible(false);
ui->num_->setVisible(false);
ui->lResult->setVisible(true);
ui->lResultNUM->setVisible(true);
instance.WriteDatabase();
instance.ReadDatabase();
ui->tableWidget->setRowCount(instance.GetSize());
ui->tableWidget->setColumnCount(5);
QString ResultNUM;
ResultNUM.setNum(static_cast<double>(score));
ui->lResultNUM->setText(ResultNUM);
ui->tableWidget->setVisible(true);
ui->centralWidget->setStyleSheet("background: rgb(27,32,36)");
QStringList low;
low.push_back("Имя");
low.push_back("Фамилия");
low.push_back("Номер Группы");
low.push_back("Баллы");
low.push_back("Дата");
ui->tableWidget->setHorizontalHeaderLabels(low);
for(int i=0;i<instance.GetSize();i++)
{
QTableWidgetItem *pName = new QTableWidgetItem;
QTableWidgetItem *pLastName = new QTableWidgetItem;
QTableWidgetItem *pGroupName = new QTableWidgetItem;
QTableWidgetItem *pTime = new QTableWidgetItem;
QTableWidgetItem *pScore = new QTableWidgetItem;
QString GroupNameConv,ScoreConv;
GroupNameConv.setNum(static_cast<double>(instance[i].GetGroupName()));
ScoreConv.setNum(static_cast<double>(instance[i].GetScore()));
pName->setText(instance[i].GetName());
pLastName->setText(instance[i].GetLastName());
pGroupName->setText(GroupNameConv);
pTime->setText(instance[i].GetTime());
pScore->setText(ScoreConv);
ui->tableWidget->setItem(i,0,pName);
ui->tableWidget->setItem(i,1,pLastName);
ui->tableWidget->setItem(i,2,pGroupName);
ui->tableWidget->setItem(i,3,pScore);
ui->tableWidget->setItem(i,4,pTime);
}
}
void CUcontent_Adjustments::setupAdjustmentsTable()
{
bool enable = false;
bool ok = false;
unsigned char k = 0;
QTableWidgetItem *tableItem = NULL;
ModQDoubleSpinBox *spinBox = NULL;
QComboBox *comboBox = NULL;
QIdPushButton *saveButton = NULL;
QPushButton *resetButton = NULL;
QPixmap leftIcon, rightIcon;
QPixmap mergedIcon(54, 22);
QStringList selectableScaledValueStr;
QString helpScaledValueStr = 0;
double minScaledValue = 0;
double maxScaledValue = 0;
double defaultScaledValue = 0;
double minSingleStepFromPrecision = 0;
double minSingleStepFromRaw = 0;
bool calcerror = false;
// Create "Save"-icon:
leftIcon.load( QString::fromUtf8(":/icons/oxygen/22x22/go-next.png") );
rightIcon.load( QString::fromUtf8(":/icons/oxygen/22x22/drive-harddisk.png") );
mergedIcon.fill(Qt::transparent);
QPainter painter(&mergedIcon);
painter.drawTiledPixmap( 0, 0, 22, 22, leftIcon );
painter.drawTiledPixmap( 32, 0, 22, 22, rightIcon );
QIcon saveButton_icon( mergedIcon );
// Create "Reset"-icon:
leftIcon.load( QString::fromUtf8(":/icons/oxygen/22x22/go-first.png") );
mergedIcon.fill(Qt::transparent);
painter.drawTiledPixmap( 0, 0, 22, 22, leftIcon );
painter.drawTiledPixmap( 32, 0, 22, 22, rightIcon );
QIcon resetButton_icon( mergedIcon );
// Clear Table:
adjustments_tableWidget->clearContents();
// Enable/Disable GUI-elements:
title_label->setEnabled( enable );
adjustments_tableWidget->setEnabled( enable );
nonPermanentInfo_label->setEnabled( enable );
// Increase nr. of table rows if necessary:
if (_supportedAdjustments.size() && (static_cast<unsigned int>(adjustments_tableWidget->rowCount()) < _supportedAdjustments.size()))
adjustments_tableWidget->setRowCount( _supportedAdjustments.size() + 2 );
// Fill Table:
for (k=0; k<_supportedAdjustments.size(); k++)
{
// Title:
tableItem = new QTableWidgetItem( _supportedAdjustments.at(k).title );
adjustments_tableWidget->setItem(k, 0, tableItem);
// Current Value:
tableItem = new QTableWidgetItem( "???" );
tableItem->setTextAlignment(Qt::AlignCenter);
adjustments_tableWidget->setItem(k, 1, tableItem);
// New Value:
if (_newValueSelWidgetType.at(k))
{
// Get selectable scaled values:
selectableScaledValueStr.clear();
getSelectableScaledValueStrings(_supportedAdjustments.at(k).formula, &selectableScaledValueStr);
// Setup and insert selection-Combobox:
comboBox = new QComboBox();
comboBox->addItems( selectableScaledValueStr );
adjustments_tableWidget->setCellWidget ( k, 2, comboBox );
}
else
{
// Calculate and set min/max:
ok = libFSSM::raw2scaled(_supportedAdjustments.at(k).rawMin, _supportedAdjustments.at(k).formula, _supportedAdjustments.at(k).precision, &helpScaledValueStr);
if (ok)
minScaledValue = helpScaledValueStr.toDouble(&ok);
if (ok)
ok = libFSSM::raw2scaled(_supportedAdjustments.at(k).rawMax, _supportedAdjustments.at(k).formula, _supportedAdjustments.at(k).precision, &helpScaledValueStr);
if (ok)
maxScaledValue = helpScaledValueStr.toDouble(&ok);
if (ok)
ok = libFSSM::raw2scaled(_supportedAdjustments.at(k).rawDefault, _supportedAdjustments.at(k).formula, _supportedAdjustments.at(k).precision, &helpScaledValueStr);
if (ok)
defaultScaledValue = helpScaledValueStr.toDouble(&ok);
if (!ok)
{
calcerror = true;
continue; // continue with next adjustment value
}
spinBox = new ModQDoubleSpinBox();
// put spinbox into the table:
adjustments_tableWidget->setCellWidget ( k, 2, spinBox );
/* NOTE: we do this here, because some spinbox functions don't work as expected (Qt-bugs ?) if spinBox is not visible yet */
// Set adjustable range:
if (minScaledValue > maxScaledValue)
spinBox->setRange(maxScaledValue, minScaledValue);
else
spinBox->setRange(minScaledValue, maxScaledValue);
// Calculate and set step size:
minSingleStepFromPrecision = pow(10, (-1*_supportedAdjustments.at(k).precision));
minSingleStepFromRaw = (maxScaledValue - minScaledValue) / (_supportedAdjustments.at(k).rawMax - _supportedAdjustments.at(k).rawMin);
/* NOTE: this only works for constant step size ! */
if (minSingleStepFromRaw > minSingleStepFromPrecision)
spinBox->setSingleStep( minSingleStepFromRaw );
else
spinBox->setSingleStep( minSingleStepFromPrecision );
// Set base value for "discrete values mode":
spinBox->setDiscreteValuesModeBaseValue(defaultScaledValue);
// Enable "discrete values mode":
spinBox->setDiscreteValuesModeEnabled(true);
// Set decimals:
spinBox->setDecimals(_supportedAdjustments.at(k).precision);
// Set suffix (unit):
spinBox->setSuffix(" " + _supportedAdjustments.at(k).unit);
// Set alignement:
spinBox->setAlignment(Qt::AlignCenter);
}
// "Save"-button:
saveButton = new QIdPushButton("", k, adjustments_tableWidget);
saveButton->setIcon(saveButton_icon);
saveButton->setIconSize( QSize(54,22) );
connect (saveButton, SIGNAL( released(unsigned int) ), this, SLOT( saveAdjustmentValue(unsigned int) ));
adjustments_tableWidget->setCellWidget ( k, 3, saveButton );
}
// Setup "Reset all"-elements:
if (_supportedAdjustments.size() > 0)
{
// Title:
tableItem = new QTableWidgetItem( tr("Reset all: ") );
tableItem->setTextAlignment(Qt::AlignVCenter | Qt::AlignRight);
adjustments_tableWidget->setItem(_supportedAdjustments.size()+1, 2, tableItem);
// "Reset all"-button:
resetButton = new QPushButton(adjustments_tableWidget);
resetButton->setIcon( resetButton_icon );
resetButton->setIconSize( QSize(54, 22) );
connect (resetButton, SIGNAL( released() ), this, SLOT( resetAllAdjustmentValues() ));
adjustments_tableWidget->setCellWidget ( _supportedAdjustments.size()+1, 3, resetButton );
}
// Check for calculation error(s):
if (calcerror)
calculationError(tr("One or more values will not be adjustable to prevent\nwrong data being written to the Control Unit."));
// NOTE: using released() instead of pressed() for buttons as workaround for a Qt-Bug occuring under MS Windows
}
