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 }