void QgsMessageLogViewer::logMessage( QString message, QString tag, QgsMessageLog::MessageLevel level )
{
#ifdef ANDROID
mCount++;
#else
mButton->setToolTip( tr( "%1 message(s) logged." ).arg( mCount++ ) );
#endif
if ( !isVisible() && level > QgsMessageLog::INFO )
{
mButton->show();
if ( mShowToolTips )
QToolTip::showText( mButton->mapToGlobal( QPoint( 0, 0 ) ), mButton->toolTip() );
}
if ( tag.isNull() )
tag = tr( "General" );
int i;
for ( i = 0; i < tabWidget->count() && tabWidget->tabText( i ) != tag; i++ )
;
QTableWidget *w;
if ( i < tabWidget->count() )
{
w = qobject_cast<QTableWidget *>( tabWidget->widget( i ) );
tabWidget->setCurrentIndex( i );
}
else
{
w = new QTableWidget( 0, 3, this );
w->verticalHeader()->setDefaultSectionSize( 16 );
w->verticalHeader()->setResizeMode( QHeaderView::ResizeToContents );
w->verticalHeader()->setVisible( false );
w->setGridStyle( Qt::DotLine );
w->setEditTriggers( QAbstractItemView::NoEditTriggers );
w->setHorizontalScrollMode( QAbstractItemView::ScrollPerPixel );
w->setVerticalScrollMode( QAbstractItemView::ScrollPerPixel );
w->setHorizontalHeaderLabels( QStringList() << tr( "Timestamp" ) << tr( "Message" ) << tr( "Level" ) );
tabWidget->addTab( w, tag );
tabWidget->setCurrentIndex( tabWidget->count() - 1 );
}
int n = w->rowCount();
w->setRowCount( n + 1 );
QTableWidgetItem *item = new QTableWidgetItem( QDateTime::currentDateTime().toString( Qt::ISODate ) );
w->setItem( n, 0, item );
w->setItem( n, 1, new QTableWidgetItem( message ) );
w->setItem( n, 2, new QTableWidgetItem( QString::number( level ) ) );
w->scrollToBottom();
w->horizontalHeader()->resizeSections( QHeaderView::ResizeToContents );
}
QWidget * Table::createQtWidget(Proxy *proxy, UIProxy *uiproxy, QWidget *parent)
{
QTableWidget *tablewidget = new TableWidget(this, parent);
tablewidget->setEnabled(enabled);
tablewidget->setVisible(visible);
tablewidget->setStyleSheet(QString::fromStdString(style));
size_t rowcount = rows.size(), columncount = 0;
for(size_t i = 0; i < rowcount; i++)
columncount = std::max(columncount, rows[i].size());
tablewidget->setRowCount(rowcount);
tablewidget->setColumnCount(columncount);
tablewidget->horizontalHeader()->setVisible(show_horizontal_header);
tablewidget->verticalHeader()->setVisible(show_vertical_header);
tablewidget->setShowGrid(show_grid);
QStringList qtHorizontalHeader;
for(size_t i = 0; i < horizontalHeader.size(); i++)
qtHorizontalHeader << QString::fromStdString(horizontalHeader[i]);
tablewidget->setHorizontalHeaderLabels(qtHorizontalHeader);
QStringList qtVerticalHeader;
for(size_t i = 0; i < verticalHeader.size(); i++)
qtVerticalHeader << QString::fromStdString(verticalHeader[i]);
tablewidget->setVerticalHeaderLabels(qtVerticalHeader);
if(autosize_horizontal_header)
tablewidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
if(autosize_vertical_header)
tablewidget->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
if(sortable)
tablewidget->setSortingEnabled(true);
for(size_t row = 0; row < rowcount; row++)
{
for(size_t column = 0; column < rows[row].size(); column++)
{
TableItem &item = rows[row][column];
QTableWidgetItem *qtwitem = new QTableWidgetItem(QString::fromStdString(item.text));
if(item.editable)
qtwitem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
else
qtwitem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
tablewidget->setItem(row, column, qtwitem);
}
}
tablewidget->setSelectionBehavior(selectionBehavior);
tablewidget->setSelectionMode(selectionMode);
QObject::connect(tablewidget, &QTableWidget::cellActivated, uiproxy, &UIProxy::onCellActivate);
QObject::connect(tablewidget, &QTableWidget::cellChanged, uiproxy, &UIProxy::onCellActivate);
QObject::connect(tablewidget, &QTableWidget::itemSelectionChanged, uiproxy, &UIProxy::onTableSelectionChange);
setQWidget(tablewidget);
setEditable(editable);
setProxy(proxy);
return tablewidget;
}
QTableWidget* DatabaseView::snapshotsTable()
{
if(tables.find(SNAPSHOTS) != tables.end())
{
return tables[SNAPSHOTS].second;
}
QList<Snapshot> snapslist = Database::getInstance().getSnapshots();
QTableWidget *table;
const QSize previewSize = QSize(64,64);
table = new QTableWidget(snapslist.count(), 6);
table->setIconSize(previewSize);
table->setHorizontalHeaderLabels(QStringList()<<"Снимок"<<"Ширина"<<"Высота"<<"Дата"<<"На сцене"<<"hidden");
table->setSelectionBehavior(QAbstractItemView::SelectRows);
int row = 0;
QByteArray imageBytes;
foreach(Snapshot snapshot,snapslist)
{
table->setItem(row, 0, new QTableWidgetItem(QPixmap::fromImage(snapshot.image.scaled(previewSize,Qt::KeepAspectRatio)),""));
table->setItem(row, 1, new QTableWidgetItem(QString("%1").arg(snapshot.width)));
table->setItem(row, 2, new QTableWidgetItem(QString("%1").arg(snapshot.height)));
table->setItem(row, 3, new QTableWidgetItem(snapshot.created.toString()));
table->setItem(row, 4, new QTableWidgetItem(snapshot.in_scene ? "Да" : "Нет"));
table->setItem(row, 5, new QTableWidgetItem(QString("%1").arg(snapshot.id)));
table->verticalHeader()->resizeSection(row, previewSize.height());
for(int i = 0; i < 4; i++)
table->item(row,i)->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
row++;
}
void PublicTalks::beforePublicTalkComboBoxShown(int rownumber)
{
// themes combobox
cPersonComboBox *c = static_cast<cPersonComboBox *>(maintable->cellWidget(rownumber,2));
cPersonComboBox *speakerCombo = static_cast<cPersonComboBox *>(maintable->cellWidget(rownumber,3));
QString currentThemeText = c->currentText();
QTableWidget *table;
cpersons cp;
person *speaker = cp.getPerson(speakerCombo->currentText());
if (speaker) {
// the speaker selected --> will be shown speaker's themes
table = this->getSpeakerPublicTalks(0,speaker->id, currentThemeText);
} else {
// no speaker selected --> all themes will be shown
table = this->getPublicTalksbyLang(currentThemeText);
}
// schoolComboBox *sc = static_cast<schoolComboBox *>(ui->tableSchoolEdit->cellWidget(row,col));
qDebug() << QString::number(table->rowCount());
table->setSortingEnabled(true);
table->sortByColumn(0,Qt::AscendingOrder);
table->verticalHeader()->hide();
table->setColumnWidth(0,40);
table->setColumnWidth(1,200);
table->setColumnWidth(2,80);
table->setMinimumWidth(340);
c->clear();
c->setModel(table->model());
c->setView(table);
c->setModelColumn(1);
c->setCurrentIndex(c->findText(currentThemeText,Qt::MatchExactly));
}
// get speaker's themes by language
QTableWidget *PublicTalks::getSpeakerPublicTalks(int kieli_id, int personid, QString select) {
QTableWidget *table = new QTableWidget(0,3);
table->verticalHeader()->setVisible(false);
//sitten vectoriin kaikki aiheet
std::vector<sql_item> q;
// q = sql.selectSql("SELECT * FROM Esitelmat, P_esitelmat WHERE Esitelmat.kieli_id = '"+ kielet[0].getValue("id") +"'"
// " AND Esitelmat.aihe_id = P_esitelmat.aihe_id"
// " AND P_esitelmat.puhuja_id = '" + QString::number(personid) + "'");
q = sql.selectSql("SELECT Esitelmat.*, P_esitelmat.puhuja_id, yleisokokous.pvm FROM Esitelmat "
"LEFT JOIN yleisokokous ON Esitelmat.aihe_id = yleisokokous.aihe_id "
"LEFT JOIN P_esitelmat ON Esitelmat.aihe_id = P_esitelmat.aihe_id "
"WHERE P_esitelmat.puhuja_id = '" + QString::number(personid) + "' "
"AND Esitelmat.kieli_id = '"+ langId +"' "
"GROUP BY Esitelmat.aihe_id ORDER BY Esitelmat.aihe_id");
table->setRowCount(q.size()+1);
for(unsigned int i = 0; i < q.size(); i++) {
int value = QVariant(q[i].getValue("aihe_id")).toInt();
QTableWidgetItem *item = new QTableWidgetItem();
item->setData(Qt::DisplayRole,value);
table->setItem(i+1,0,item);
//table->setItem(i+1,0,new QTableWidgetItem(q[i].getValue("aihe_id")));
table->setItem(i+1,1,new QTableWidgetItem(q[i].getValue("aihe")));
if(table->item(i+1,1)->text() == select) {
QFont boldfont(table->item(i+1,1)->font().family(),
table->item(i+1,1)->font().pointSize(),
QFont::Bold);
table->item(i+1,1)->setFont(boldfont);
}
table->setItem(i+1,2,new QTableWidgetItem(q[i].getValue("pvm")));
}
return table;
}
static QTableWidget* createFilesTable(const QStringList &fileNames)
{
QTableWidget *table = new QTableWidget(0, 2);
table->setSelectionMode(QAbstractItemView::NoSelection);
QStringList labels({
QCoreApplication::translate("AddImageToResources","Filename"),
QCoreApplication::translate("AddImageToResources","Size")
});
table->setHorizontalHeaderLabels(labels);
table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
table->verticalHeader()->hide();
table->setShowGrid(false);
for (const QString &filePath : fileNames) {
const QString toolTip = QDir::toNativeSeparators(filePath);
const QString fileName = QFileInfo(filePath).fileName();
const qint64 size = QFileInfo(filePath).size() / 1024;
QTableWidgetItem *fileNameItem = new QTableWidgetItem(fileName);
fileNameItem->setToolTip(toolTip);
fileNameItem->setFlags(fileNameItem->flags() ^ Qt::ItemIsEditable);
QTableWidgetItem *sizeItem = new QTableWidgetItem(QString::number(size) + " KB");
sizeItem->setToolTip(toolTip);
sizeItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
sizeItem->setFlags(sizeItem->flags() ^ Qt::ItemIsEditable);
int row = table->rowCount();
table->insertRow(row);
table->setItem(row, 0, fileNameItem);
table->setItem(row, 1, sizeItem);
}
return table;
}
void Window::createGUI()
{
QList<QPair<QString, QColor> > list;
list << QPair<QString, QColor>(tr("Alice"), QColor("aliceblue")) <<
QPair<QString, QColor>(tr("Neptun"), QColor("aquamarine")) <<
QPair<QString, QColor>(tr("Ferdinand"), QColor("springgreen"));
QTableWidget *table = new QTableWidget(3, 2);
table->setHorizontalHeaderLabels(QStringList() << tr("Name")
<< tr("Hair Color"));
table->verticalHeader()->setVisible(false);
table->resize(150, 50);
for (int i = 0; i < 3; ++i) {
QPair<QString, QColor> pair = list.at(i);
QTableWidgetItem *nameItem = new QTableWidgetItem(pair.first);
QTableWidgetItem *colorItem = new QTableWidgetItem;
colorItem->setData(Qt::DisplayRole, pair.second);
table->setItem(i, 0, nameItem);
table->setItem(i, 1, colorItem);
}
table->resizeColumnToContents(0);
table->horizontalHeader()->setStretchLastSection(true);
QGridLayout *layout = new QGridLayout;
layout->addWidget(table, 0, 0);
setLayout(layout);
setWindowTitle(tr("Color Editor Factory"));
}
InformationPanel::InformationPanel(QWidget *parent)
: ConfiguratorPanel(false, parent) {
_name = "Information";
_icon = QIcon(":/res/icons/info.png");
setHeadline("Information");
setDescription("System paths and variables");
QVBoxLayout *l = new QVBoxLayout;
l->setMargin(0);
setLayout(l);
QTableWidget *table = new QTableWidget;
table->setFrameShape(QFrame::NoFrame);
table->setColumnCount(2);
table->verticalHeader()->setVisible(false);
table->horizontalHeader()->setStretchLastSection(true);
table->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
table->setHorizontalHeaderLabels(QStringList() << "Name" << "Value");
table->setAlternatingRowColors(true);
table->setSelectionMode(QAbstractItemView::NoSelection);
l->addWidget(table);
Seiscomp::Environment *env = Seiscomp::Environment::Instance();
addRow(table, "PATH", getenv("PATH"));
addRow(table, "ROOTDIR", env->installDir().c_str());
addRow(table, "DEFAULTCONFIGDIR", env->globalConfigDir().c_str());
addRow(table, "SYSTEMCONFIGDIR", env->appConfigDir().c_str());
addRow(table, "CONFIGDIR", env->configDir().c_str());
addRow(table, "LOGDIR", env->logDir().c_str());
addRow(table, "DATADIR", env->shareDir().c_str());
table->resizeColumnsToContents();
}
void TrainLinePanel::__initTableHeader()
{
int listLineCount = ui->listWidget->count();
for(int i = 0; i < listLineCount;i++)
{
QTableWidget *tableWidget = new QTableWidget;
tableWidget->setAlternatingRowColors(true);
tableWidget->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
tableWidget->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
// connect(tableWidget,SIGNAL(doubleClicked(QModelIndex)),keyboard,SLOT(show(QModelIndex)));
tableWidget->verticalHeader()->setHidden(true);
tableWidget->setColumnCount(10);
tableWidget->setColumnHidden(9,true);
tableWidget->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
tableWidget->horizontalHeader()->setMinimumHeight(30);
tableWidget->horizontalHeader()->setMinimumSectionSize(140);
QTableWidgetItem* item = new QTableWidgetItem("Station number");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(0,item);
item = new QTableWidgetItem("Station id");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(1,item);
item = new QTableWidgetItem("Name(EN)");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(2,item);
item = new QTableWidgetItem("Name(TH)");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(3,item);
item = new QTableWidgetItem("Start time");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(4,item);
item = new QTableWidgetItem("Arrive time");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(5,item);
item = new QTableWidgetItem("Lng");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(6,item);
item = new QTableWidgetItem("Lat");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(7,item);
item = new QTableWidgetItem("Sea level");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(8,item);
item = new QTableWidgetItem("Rowid");
item->setTextAlignment(Qt::AlignHCenter);
tableWidget->setHorizontalHeaderItem(9,item);
ui->stackedWidget->addWidget(tableWidget);
}
// connect(tableWidget,SIGNAL(itemChanged(QTableWidgetItem*)),this,SLOT(updateDatabase(QTableWidgetItem*)));
}
std::string Table::saveState()
{
QTableWidget *tablewidget = static_cast<QTableWidget*>(getQWidget());
QByteArray hhState = tablewidget->horizontalHeader()->saveState();
QByteArray vhState = tablewidget->verticalHeader()->saveState();
size_t len1 = hhState.length(), len2 = vhState.length();
std::string hh(hhState.constData(), hhState.length()), vh(vhState.constData(), vhState.length());
std::string state = boost::lexical_cast<std::string>(len1) + ":" + boost::lexical_cast<std::string>(len2) + ":" + hh + vh;
return state;
}
Legend::Legend(QWidget *parent) :
QDialog(parent)
{
QLabel *label;
QVBoxLayout *layout = new QVBoxLayout();
setLayout(layout);
DNSData d;
Node *n = new Node(0);
layout->addWidget(label = new QLabel(tr("<h2>DNSSEC-Nodes Coloring Legend</h2>")));
label->setAlignment(Qt::AlignHCenter);
QList<int> statuses;
statuses << DNSData::UNKNOWN << DNSData::TRUSTED << DNSData::VALIDATED << DNSData::DNE
<< DNSData::FAILED << DNSData::IGNORE << (DNSData::DNE | DNSData::VALIDATED);
// Add the legend widget
QTableWidget *table = new QTableWidget(statuses.count(), 2, this);
layout->addWidget(table);
table->setHorizontalHeaderItem(0, new QTableWidgetItem(tr("Node")));
table->setHorizontalHeaderItem(1, new QTableWidgetItem(tr("Description")));
table->verticalHeader()->hide();
QPointF rect = n->boundingRect().bottomRight() - n->boundingRect().topLeft();
QSize size(rect.x() + 2, rect.y() + 2);
QPointF br = n->boundingRect().bottomRight();
int row = 0;
foreach(int status, statuses) {
QTableWidgetItem *item = new QTableWidgetItem(d.DNSSECStatusForEnum(status));
item->setFlags(Qt::ItemIsEnabled);
item->setBackgroundColor(n->getColorForStatus(status).lighter());
table->setItem(row, 1, item);
Node *node = new Node(0);
QPixmap pm = QPixmap(size);
QPainter painter(&pm);
node->addSubData(DNSData("", status));
painter.setBackground(Qt::white);
painter.setBrush(Qt::white);
painter.drawRect(-5, -5, size.width() + 5, size.height() + 5);
painter.translate(br.x(), br.y());
node->paint(&painter, 0, 0);
QIcon icon = QIcon(pm);
item = new QTableWidgetItem(icon, "");
item->setFlags(Qt::ItemIsEnabled);
table->setItem(row, 0, item);
row++;
}
void MainWindow::standartStuffForAllTables(QTableWidget& table)
{
table.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
table.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
table.setEditTriggers(QAbstractItemView::NoEditTriggers);
table.verticalHeader()->hide();
table.horizontalHeader()->hide();
table.setEditTriggers(QAbstractItemView::NoEditTriggers);
table.setSelectionMode(QAbstractItemView::NoSelection);
table.setFocusPolicy(Qt::NoFocus);
}
QList<QWidget*> DataProvider::toolboxPages() {
QList<QWidget*> l;
// ---------------- Info Table ---------------------------
QList<QString> keys = providerInformation.keys();
QTableWidget* table = new QTableWidget(keys.size(),2);
for (int i=0; i<keys.size(); i++) {
table->setItem(i, 0, new QTableWidgetItem(keys.at(i)));
table->setItem(i, 1, new QTableWidgetItem(providerInformation[keys.at(i)].toString()));
table->item(i,0)->setFlags(Qt::ItemIsEnabled);
table->item(i,1)->setFlags(Qt::ItemIsEnabled);
}
table->setObjectName("Info");
table->horizontalHeader()->setStretchLastSection(true);
table->verticalHeader()->setDefaultSectionSize(table->fontMetrics().lineSpacing()+5);
table->verticalHeader()->hide();
table->horizontalHeader()->hide();
l << table;
// ---------------------------------------------------------
return l;
}
bool Table::restoreState(std::string state)
{
QTableWidget *tablewidget = static_cast<QTableWidget*>(getQWidget());
size_t d1 = state.find(":"), d2 = state.find(":", d1 + 1);
std::string slen1 = state.substr(0, d1), slen2 = state.substr(d1 + 1, d2 - d1);
size_t len1 = boost::lexical_cast<size_t>(slen1), len2 = boost::lexical_cast<size_t>(slen2);
const char *s = state.c_str() + d2 + 1;
QByteArray hhState(s, len1), vhState(s + len1, len2);
bool ret = true;
ret = ret && tablewidget->horizontalHeader()->restoreState(hhState);
ret = ret && tablewidget->verticalHeader()->restoreState(vhState);
return ret;
}
int main( int argc, char* argv[] )
{
QApplication app( argc, argv );
QTableWidget* tv = new QTableWidget();
tv->setRowCount( 1440 );
tv->setColumnCount( 3 );
tv->setShowGrid( false );
QHeaderView* vh = tv->verticalHeader();
vh->sectionResizeMode( QHeaderView::Fixed );
vh->setDefaultSectionSize( 4 );
QLabel* lbl = new QLabel( "abc" );
tv->setCellWidget( 1, 1, lbl );
tv->setSpan( 1, 1, 10, 1 );
tv->show();
app.exec();
}
QTableWidget *PublicTalks::getPersons(int type)
{
std::vector<sql_item> vt;
// QString str = "SELECT yleisokokous.pvm, henkilot.nimi, henkilot.id, henkilot.etunimi "
// "FROM henkilot LEFT JOIN yleisokokous ON henkilot.id = yleisokokous.puheenjohtaja_id "
// "WHERE ohjelmatyypit & " + QString::number(type) + " GROUP BY henkilot.id";
QString str = "SELECT yleisokokous.pvm, henkilot.nimi, henkilot.id, henkilot.etunimi "
"FROM henkilot LEFT JOIN yleisokokous ON henkilot.id = yleisokokous.";
if(type == person::chairman) {
str.append("puheenjohtaja_id");
} else {
str.append("vt_lukija_id");
}
str.append(" WHERE ohjelmatyypit & " + QString::number(type) + " GROUP BY henkilot.id");
vt = sql.selectSql(str);
QTableWidget *vttable = new QTableWidget();
vttable->horizontalHeader()->show();
vttable->verticalHeader()->setVisible(false);
vttable->setColumnCount(3);
vttable->setColumnHidden(0,true);
vttable->setColumnWidth(1,150);
vttable->setColumnWidth(2,100);
vttable->setMinimumWidth(270);
vttable->setSortingEnabled(true);
vttable->setHorizontalHeaderItem(1,new QTableWidgetItem(QObject::tr("Name")));
vttable->setHorizontalHeaderItem(2,new QTableWidgetItem(QObject::tr("Last")));
vttable->setRowCount(vt.size()+1);
vttable->setItem(0,0,new QTableWidgetItem(""));
for(unsigned int i = 0; i < vt.size(); i++) {
vttable->setItem(i+1,0,new QTableWidgetItem(vt[i].getValue("id")));
vttable->setItem(i+1,1,new QTableWidgetItem(vt[i].getValue("nimi") + " " + vt[i].getValue("etunimi")));
vttable->setItem(i+1,2,new QTableWidgetItem(vt[i].getValue("pvm")));
}
return vttable;
}
QTableWidget* AutoImportWindow::setupFilesTable() {
QTableWidget* filesTable = new QTableWidget(0, 6);
filesTable->setSelectionBehavior(QAbstractItemView::SelectRows);
filesTable->setAttribute(Qt::WA_MacShowFocusRect, 0);
QStringList labels;
labels << "" << tr("Directory") << tr("Search Name") << tr("Averaged") << tr("Aligned") << tr("Raw");
filesTable->setHorizontalHeaderLabels(labels);
filesTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::Stretch);
filesTable->verticalHeader()->hide();
filesTable->setShowGrid(false);
filesTable->setAlternatingRowColors(true);
connect(filesTable, &QTableWidget::itemDoubleClicked, [=](QTableWidgetItem *item){
if(item->row() != -1 && item->row() < rowToImagePaths_.size()) {
QString path = rowToImagePaths_[item->row()];
ProjectImage* image = projectData.projectImage(QDir(projectData.projectDir().absoluteFilePath(path)));
if(image) emit imageToBeOpened(image);
else QMessageBox::warning(this, "Image Open Error!", "Image: " + path + " was either not imported or not found.");
}
});
return filesTable;
}
void model_import_dlg::create_mesh_tab(QTabWidget * parent, size_t index, render::lod lod)
{
QWidget * tab = new QWidget(parent);
tab->setObjectName("meshTab");
auto & geometry = conv.get(index).geometry.at(lod);
auto & material = conv.get(index).materials.at(lod);
QGroupBox * geometry_box = new QGroupBox(tab);
geometry_box->setGeometry(10, 10, 561, 115);
geometry_box->setTitle("Geometry");
QLabel * vertices = new QLabel(geometry_box);
vertices->setGeometry(20, 20, 200, 20);
vertices->setText("Vertices: " + QString::number(geometry.vertex_count));
QLabel * faces = new QLabel(geometry_box);
faces->setGeometry(20, 40, 200, 20);
faces->setText("Faces: " + QString::number(geometry.index_count / 3));
QLabel * indices = new QLabel(geometry_box);
indices->setGeometry(20, 60, 200, 20);
indices->setText("Indices: " + QString::number(geometry.index_count));
QLabel * layout = new QLabel(geometry_box);
layout->setGeometry(20, 80, 200, 20);
layout->setText("Layout: " + QString::fromStdString(render::vertex::str(geometry.vertex_type)));
QGroupBox * material_box = new QGroupBox(tab);
material_box->setGeometry(10, 130, 561, 400);
material_box->setTitle("Material");
QGroupBox * colors_box = new QGroupBox(material_box);
colors_box->setGeometry(15, 20, 455, 134);
colors_box->setTitle("Colors");
QTableWidget * colorsTable = new QTableWidget(colors_box);
colorsTable->setGeometry(15, 25, 237, 92);
colorsTable->setObjectName("colorsTable");
colorsTable->setRowCount(3);
colorsTable->setColumnCount(3);
colorsTable->setFrameShape(QFrame::NoFrame);
colorsTable->setShowGrid(false);
colorsTable->setSelectionBehavior(QAbstractItemView::SelectionBehavior::SelectRows);
colorsTable->setEditTriggers(QAbstractItemView::DoubleClicked);
colorsTable->horizontalHeader()->setDefaultSectionSize(60);
colorsTable->verticalHeader()->setDefaultSectionSize(23);
colorsTable->setSelectionMode(QAbstractItemView::SelectionMode::SingleSelection);
QStringList color_types;
color_types.append("Ambient");
color_types.append("Diffuse");
color_types.append("Specular");
QStringList color_channels;
color_channels.append("R");
color_channels.append("G");
color_channels.append("B");
colorsTable->setVerticalHeaderLabels(color_types);
colorsTable->setHorizontalHeaderLabels(color_channels);
colorsTable->setItem(0, 0, new QTableWidgetItem(QString::number(rgb_to_byte(material.ambient.x))));
colorsTable->setItem(0, 1, new QTableWidgetItem(QString::number(rgb_to_byte(material.ambient.y))));
colorsTable->setItem(0, 2, new QTableWidgetItem(QString::number(rgb_to_byte(material.ambient.z))));
colorsTable->setItem(1, 0, new QTableWidgetItem(QString::number(rgb_to_byte(material.diffuse.x))));
colorsTable->setItem(1, 1, new QTableWidgetItem(QString::number(rgb_to_byte(material.diffuse.y))));
colorsTable->setItem(1, 2, new QTableWidgetItem(QString::number(rgb_to_byte(material.diffuse.z))));
colorsTable->setItem(2, 0, new QTableWidgetItem(QString::number(rgb_to_byte(material.specular.x))));
colorsTable->setItem(2, 1, new QTableWidgetItem(QString::number(rgb_to_byte(material.specular.y))));
colorsTable->setItem(2, 2, new QTableWidgetItem(QString::number(rgb_to_byte(material.specular.z))));
QPushButton * colorPick = new QPushButton(colors_box);
colorPick->setGeometry(290, 24, 75, 23);
colorPick->setObjectName("colorPick");
colorPick->setText("Pick");
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
colorsTable->item(i, j)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
QObject::connect(colorsTable, SIGNAL(itemSelectionChanged()), this, SLOT(on_color_table_changed()));
QObject::connect(colorPick, SIGNAL(pressed()), this, SLOT(on_color_pick()));
QLabel * spec_power = new QLabel(colors_box);
spec_power->setGeometry(290, 89, 80, 23);
spec_power->setText("Specular power: ");
QDoubleSpinBox * spec_power_box = new QDoubleSpinBox(colors_box);
spec_power_box->setObjectName("specularSpinBox");
spec_power_box->setDecimals(2);
spec_power_box->setSingleStep(0.05);
spec_power_box->setFrame(false);
spec_power_box->setGeometry(390, 89, 50, 23);
spec_power_box->setValue(material.specular_power);
QGroupBox * textures_box = new QGroupBox(material_box);
textures_box->setGeometry(15, 159, 531, 225);
textures_box->setTitle("Textures");
QTableWidget * texturesTable = new QTableWidget(textures_box);
texturesTable->setObjectName("texturesTable");
texturesTable->setGeometry(15, 25, 500, 150);
texturesTable->setRowCount(material.textures.size());
texturesTable->setColumnCount(2);
texturesTable->setFrameShape(QFrame::NoFrame);
texturesTable->setShowGrid(false);
texturesTable->setSelectionBehavior(QAbstractItemView::SelectionBehavior::SelectRows);
texturesTable->setEditTriggers(QAbstractItemView::DoubleClicked);
texturesTable->horizontalHeader()->setDefaultSectionSize(60);
texturesTable->verticalHeader()->setDefaultSectionSize(23);
texturesTable->verticalHeader()->setVisible(false);
QStringList texture_headers;
texture_headers.append("File");
texture_headers.append("Type");
texturesTable->setHorizontalHeaderLabels(texture_headers);
int i = 0;
assimp::texture_type_map texture_map;
for (auto texture : material.textures)
{
texturesTable->setItem(i, 0, new QTableWidgetItem(QString::fromStdString(texture.second.texture_path.generic_string())));
texturesTable->setItem(i, 1, new QTableWidgetItem(QString::fromStdString(texture_map.get(texture.first))));
texturesTable->setColumnWidth(0, 350);
texturesTable->setColumnWidth(1, 150);
i++;
}
for (i = 0; i < texturesTable->rowCount(); i++)
for (int j = 0; j < texturesTable->columnCount(); j++)
texturesTable->item(i, j)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
QPushButton * add_texture = new QPushButton(textures_box);
add_texture->setGeometry(15, 185, 75, 23);
add_texture->setText("Add");
QPushButton * edit_texture = new QPushButton(textures_box);
edit_texture->setGeometry(100, 185, 75, 23);
edit_texture->setObjectName("textureEditButton");
edit_texture->setText("Edit");
edit_texture->setEnabled(false);
QPushButton * delete_texture = new QPushButton(textures_box);
delete_texture->setGeometry(185, 185, 75, 23);
delete_texture->setObjectName("textureDeleteButton");
delete_texture->setText("Delete");
delete_texture->setEnabled(false);
QObject::connect(texturesTable, SIGNAL(itemSelectionChanged()), this, SLOT(on_texture_table_changed()));
QObject::connect(add_texture, SIGNAL(pressed()), this, SLOT(on_texture_add()));
QObject::connect(edit_texture, SIGNAL(pressed()), this, SLOT(on_texture_edit()));
QObject::connect(delete_texture, SIGNAL(pressed()), this, SLOT(on_texture_delete()));
QString title = "Mesh " + QString::number(index);
parent->addTab(tab, title);
}
KeyBinder::KeyBinder(QWidget * parent, const QString & helpText, const QString & defaultText, const QString & resetButtonText) : QWidget(parent)
{
this->defaultText = defaultText;
enableSignal = false;
// Two-column tab layout
QHBoxLayout * pageKeysLayout = new QHBoxLayout(this);
pageKeysLayout->setSpacing(0);
pageKeysLayout->setContentsMargins(0, 0, 0, 0);
// Table for category list
QVBoxLayout * catListContainer = new QVBoxLayout();
catListContainer->setContentsMargins(10, 10, 10, 10);
catList = new QListWidget();
catList->setFixedWidth(180);
catList->setStyleSheet("QListWidget::item { font-size: 14px; } QListWidget:hover { border-color: #F6CB1C; } QListWidget::item:selected { background: #150A61; color: yellow; }");
catList->setFocusPolicy(Qt::NoFocus);
connect(catList, SIGNAL(currentRowChanged(int)), this, SLOT(changeBindingsPage(int)));
catListContainer->addWidget(catList);
pageKeysLayout->addLayout(catListContainer);
// Reset all binds button
if (!resetButtonText.isEmpty())
{
QPushButton * btnResetAll = new QPushButton(resetButtonText);
catListContainer->addWidget(btnResetAll);
btnResetAll->setFixedHeight(40);
catListContainer->setStretch(1, 0);
catListContainer->setSpacing(10);
connect(btnResetAll, SIGNAL(clicked()), this, SIGNAL(resetAllBinds()));
}
// Container for pages of key bindings
QWidget * bindingsPagesContainer = new QWidget();
QVBoxLayout * rightLayout = new QVBoxLayout(bindingsPagesContainer);
// Scroll area for key bindings
QScrollArea * scrollArea = new QScrollArea();
scrollArea->setContentsMargins(0, 0, 0, 0);
scrollArea->setWidget(bindingsPagesContainer);
scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
scrollArea->setWidgetResizable(true);
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setStyleSheet("background: #130F2A;");
// Add key binding pages to bindings tab
pageKeysLayout->addWidget(scrollArea);
pageKeysLayout->setStretch(1, 1);
// Custom help text
QLabel * helpLabel = new QLabel();
helpLabel->setText(helpText);
helpLabel->setStyleSheet("color: #130F2A; background: #F6CB1C; border: solid 4px #F6CB1C; border-radius: 10px; padding: auto 20px;");
helpLabel->setFixedHeight(24);
rightLayout->addWidget(helpLabel, 0, Qt::AlignCenter);
// Category list and bind table row heights
const int rowHeight = 20;
QSize catSize, headerSize;
catSize.setHeight(36);
headerSize.setHeight(24);
// Category list header
QListWidgetItem * catListHeader = new QListWidgetItem(tr("Category"));
catListHeader->setSizeHint(headerSize);
catListHeader->setFlags(Qt::NoItemFlags);
catListHeader->setForeground(QBrush(QColor("#130F2A")));
catListHeader->setBackground(QBrush(QColor("#F6CB1C")));
catListHeader->setTextAlignment(Qt::AlignCenter);
catList->addItem(catListHeader);
// Populate
bindingsPages = new QHBoxLayout();
bindingsPages->setContentsMargins(0, 0, 0, 0);
rightLayout->addLayout(bindingsPages);
QWidget * curPage = NULL;
QVBoxLayout * curLayout = NULL;
QTableWidget * curTable = NULL;
bool bFirstPage = true;
selectedBindTable = NULL;
bindComboBoxCellMappings = new QHash<QObject *, QTableWidgetItem *>();
bindCellComboBoxMappings = new QHash<QTableWidgetItem *, QComboBox *>();
for (int i = 0; i < BINDS_NUMBER; i++)
{
if (cbinds[i].category != NULL)
{
// Add stretch at end of previous layout
if (curLayout != NULL) curLayout->insertStretch(-1, 1);
// Category list item
QListWidgetItem * catItem = new QListWidgetItem(HWApplication::translate("binds (categories)", cbinds[i].category));
catItem->setSizeHint(catSize);
catList->addItem(catItem);
// Create new page
curPage = new QWidget();
curLayout = new QVBoxLayout(curPage);
curLayout->setSpacing(2);
bindingsPages->addWidget(curPage);
if (!bFirstPage) curPage->setVisible(false);
}
// Description
if (cbinds[i].description != NULL)
{
QLabel * desc = new QLabel(HWApplication::translate("binds (descriptions)", cbinds[i].description));
curLayout->addWidget(desc, 0);
QFrame * divider = new QFrame();
divider->setFrameShape(QFrame::HLine);
divider->setFrameShadow(QFrame::Plain);
curLayout->addWidget(divider, 0);
}
// New table
if (cbinds[i].category != NULL || cbinds[i].description != NULL)
{
curTable = new QTableWidget(0, 2);
curTable->verticalHeader()->setVisible(false);
curTable->horizontalHeader()->setVisible(false);
curTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
curTable->verticalHeader()->setDefaultSectionSize(rowHeight);
curTable->setShowGrid(false);
curTable->setStyleSheet("QTableWidget { border: none; } ");
curTable->setSelectionBehavior(QAbstractItemView::SelectRows);
curTable->setSelectionMode(QAbstractItemView::SingleSelection);
curTable->setFocusPolicy(Qt::NoFocus);
connect(curTable, SIGNAL(itemSelectionChanged()), this, SLOT(bindSelectionChanged()));
connect(curTable, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(bindCellClicked(QTableWidgetItem *)));
curLayout->addWidget(curTable, 0);
}
// Hidden combo box
QComboBox * comboBox = CBBind[i] = new QComboBox(curTable);
comboBox->setModel((QAbstractItemModel*)DataManager::instance().bindsModel());
comboBox->setVisible(false);
comboBox->setFixedWidth(200);
// Table row
int row = curTable->rowCount();
QTableWidgetItem * nameCell = new QTableWidgetItem(HWApplication::translate("binds", cbinds[i].name));
nameCell->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
curTable->insertRow(row);
curTable->setItem(row, 0, nameCell);
QTableWidgetItem * bindCell = new QTableWidgetItem(comboBox->currentText());
bindCell->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
curTable->setItem(row, 1, bindCell);
curTable->resizeColumnsToContents();
curTable->setFixedHeight(curTable->verticalHeader()->length() + 10);
// Updates the text in the table cell
connect(comboBox, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(bindChanged(const QString &)));
// Map combo box and that row's cells to each other
bindComboBoxCellMappings->insert(comboBox, bindCell);
bindCellComboBoxMappings->insert(nameCell, comboBox);
bindCellComboBoxMappings->insert(bindCell, comboBox);
}
void FenPrincipale::calcul_manches() {
for (int j = 0; j < this->nbManches; ++j) {
// on initialise la table html pour l'export
QString html = "<table>\n\t<thead>\n\t\t<tr>\n\t\t\t";
html += "<td>"+tr("Place")+"</td>";
html += "<td>"+tr("Équipage")+"</td>";
html += "<td>"+tr("Points")+"</td>";
if (this->typeClmt == CLMT_TEMPS) {
html += "<td>"+tr("Temps réel")+"</td><td>"+tr("Temps compensé")+"</td>";
}
html += "\n\t\t</tr>\n\t</thead>\n\t<tboby>";
// on affiche la table qui va contenir les résultats de la manche
QTableWidget *table = new QTableWidget();
table->verticalHeader()->hide();
table->setSelectionMode(QAbstractItemView::NoSelection);
table->setProperty("table", "manches");
QList<QString> labels;
labels << tr("Place") << tr("Équipage") << tr("Points");
if (this->typeClmt == CLMT_TEMPS) {
table->setColumnCount(5);
labels << tr("Temps réel") << tr("Temps compensé");
table->setMaximumWidth(560 + 20);
table->setMinimumWidth(560 + 20);
table->setColumnWidth(3, 120);
table->setColumnWidth(4, 120);
}
else {
table->setColumnCount(3);
table->setMaximumWidth(320 + 20);
table->setMinimumWidth(320 + 20);
}
table->setColumnWidth(0, 60);
table->setColumnWidth(1, 200);
table->setColumnWidth(2, 60);
table->setHorizontalHeaderLabels(labels);
table->setRowCount(this->nbEquipages);
ui->choisirResultat->insertItem(j+1,
tr("Résultats de la manche %1").arg(QString::number(j+1)));
int nbAffiches = 0; // pour savoir à quelle ligne on en est
// on traite et affiche les équipages
// on traite chaque manche pour attribuer les points aux équipages
for (int i = 0; i < this->nbEquipages; ++i) {
// on recherche tous les équipages non encore traités pour cette
// manches qui ont un tpsCompense minimal
int min = 0;
QList<int> ids;
for (int k = 0; k < this->nbEquipages; ++k) {
Manche m = this->equipages[k].manches[j];
if (m.tpsCompense < 0 || m.points > 0 ) {
// cet équipage a déjà été traité ou n'a pas de place/temps
// (DNF, DNS, OCS, ...)
continue;
}
if (m.tpsCompense < min || min == 0) {
min = m.tpsCompense;
ids.clear();
ids.append(k);
}
else if (m.tpsCompense == min) {
ids.append(k);
}
}
if (min == 0) {
// on n'a pas trouvé d'équipage à traiter (se produit s'il y a
// des équipages DNS, DNF, OCS, ...)
break;
}
for (int l = 0; l < ids.size(); ++l) {
double points = (ids.size()-1.0)/2.0+i+1.0;
this->equipages[ids.at(l)].points += points;
this->equipages[ids.at(l)].pointsOrdonnes.prepend(points);
this->equipages[ids.at(l)].pointsTries.append(points);
this->equipages[ids.at(l)].manches[j].points = points;
// on affiche ces équipages
Equipage e = this->equipages[ids.at(l)];
Manche m = e.manches[j];
QLabel *place = new QLabel(QString::number(i+1));
table->setCellWidget(i+l, 0, place);
QWidget *nomWidget = new QWidget();
QVBoxLayout *nomLayout = new QVBoxLayout();
QLabel *nom = new QLabel(e.nom);
nom->setProperty("label", "nom");
nomLayout->addWidget(nom);
if (this->typeClmt == CLMT_TEMPS) {
QLabel *bateau = new QLabel();
bateau->setText(this->bateaux.value(e.rating.toUpper()).serie
+" ("+QString::number(e.coef)+")");
bateau->setProperty("label", "bateau");
nomLayout->addWidget(bateau);
table->setRowHeight(i+l, 45);
}
nomLayout->setContentsMargins(0, 0, 0, 0);
nomLayout->setSpacing(0);
nomWidget->setLayout(nomLayout);
table->setCellWidget(i+l, 1, nomWidget);
QLabel *pointsi = new QLabel(QString::number(m.points));
table->setCellWidget(i+l, 2, pointsi);
if (this->typeClmt == CLMT_TEMPS) {
QLabel *tpsReel = new QLabel(this->formate_tps(m.tpsReel));
table->setCellWidget(i+l, 3, tpsReel);
QLabel *tpsCompense = new QLabel(this->formate_tps(qRound(m.tpsCompense)));
table->setCellWidget(i+l, 4, tpsCompense);
}
// on ajoute l'équipage à la table html
QString nomString = "<span class=\"equipage\">"+e.nom+"</span>";
if (this->typeClmt == CLMT_TEMPS) {
nomString += "<span class=\"bateau\">"
+this->bateaux.value(e.rating.toUpper()).serie
+" ("+QString::number(e.coef)+")</span>";
}
html += "\n\t\t<tr>\n\t\t\t<td>"+QString::number(i+1)+"</td>"
+"<td>"+nomString+"</td>"
+"<td>"+QString::number(m.points)+"</td>";
if (this->typeClmt == CLMT_TEMPS) {
html += "<td>"+this->formate_tps(m.tpsReel)+"</td>"
+"<td>"+this->formate_tps(qRound(m.tpsCompense))+"</td>";
}
html += "\n\t\t</tr>";
++nbAffiches;
}
i = i+ids.size()-1;
}
// on traite les équipages qui n'ont pas de place/temps
for (int i = 0; i < this->nbEquipages; ++i) {
if (this->equipages[i].manches[j].tpsCompense < 0) {
double points = this->nbEquipages+1.0;
this->equipages[i].points += points;
this->equipages[i].pointsOrdonnes.prepend(points);
this->equipages[i].pointsTries.append(points);
this->equipages[i].manches[j].points = points;
// on affiche ces équipages
Equipage e = this->equipages[i];
Manche m = e.manches[j];
QString abr = this->get_abr(m.abr);
QLabel *place = new QLabel(abr);
table->setCellWidget(nbAffiches, 0, place);
QWidget *nomWidget = new QWidget();
QVBoxLayout *nomLayout = new QVBoxLayout();
QLabel *nom = new QLabel(e.nom);
nom->setProperty("label", "nom");
nomLayout->addWidget(nom);
if (this->typeClmt == CLMT_TEMPS) {
QLabel *bateau = new QLabel();
bateau->setText(this->bateaux.value(e.rating.toUpper()).serie
+" ("+QString::number(e.coef)+")");
bateau->setProperty("label", "bateau");
nomLayout->addWidget(bateau);
table->setRowHeight(nbAffiches, 45);
}
nomLayout->setContentsMargins(0, 0, 0, 0);
nomLayout->setSpacing(0);
nomWidget->setLayout(nomLayout);
table->setCellWidget(nbAffiches, 1, nomWidget);
QLabel *pointsi = new QLabel(QString::number(m.points));
table->setCellWidget(nbAffiches, 2, pointsi);
if (this->typeClmt == CLMT_TEMPS) {
QLabel *tpsReel = new QLabel(abr);
table->setCellWidget(nbAffiches, 3, tpsReel);
QLabel *tpsCompense = new QLabel(abr);
table->setCellWidget(nbAffiches, 4, tpsCompense);
}
// on ajoute l'équipage à la table html
QString nomString = "<span class=\"equipage\">"+e.nom+"</span>";
if (this->typeClmt == CLMT_TEMPS) {
nomString += "<span class=\"bateau\">"
+this->bateaux.value(e.rating.toUpper()).serie
+" ("+QString::number(e.coef)+")</span>";
}
html += "\n\t\t<tr>\n\t\t\t<td>"+abr+"</td><td>"+nomString+"</td>"
+"<td>"+QString::number(m.points)+"</td>";
if (this->typeClmt == CLMT_TEMPS) {
html += "<td>"+abr+"</td><td>"+abr+"</td>";
}
html += "\n\t\t</tr>";
++nbAffiches;
}
}
ui->resultatsLayout->addWidget(table);
table->hide();
html += "\n\t</tbody>\n</table>";
this->htmls.append(html);
this->progression(5+j*75/this->nbManches);
}
// on trie les liste pointsTries
for (int i = 0; i < this->nbEquipages; ++i) {
qSort(this->equipages[i].pointsTries);
}
}
void QgsVectorGradientColorRampV2Dialog::on_btnInformation_pressed()
{
if ( mRamp->info().isEmpty() )
return;
QgsDialog *dlg = new QgsDialog( this );
QLabel *label = 0;
// information table
QTableWidget *tableInfo = new QTableWidget( dlg );
tableInfo->verticalHeader()->hide();
tableInfo->horizontalHeader()->hide();
tableInfo->setRowCount( mRamp->info().count() );
tableInfo->setColumnCount( 2 );
int i = 0;
for ( QgsStringMap::const_iterator it = mRamp->info().constBegin();
it != mRamp->info().constEnd(); ++it )
{
if ( it.key().startsWith( "cpt-city" ) )
continue;
tableInfo->setItem( i, 0, new QTableWidgetItem( it.key() ) );
tableInfo->setItem( i, 1, new QTableWidgetItem( it.value() ) );
tableInfo->resizeRowToContents( i );
i++;
}
tableInfo->resizeColumnToContents( 0 );
tableInfo->horizontalHeader()->setStretchLastSection( true );
tableInfo->setRowCount( i );
tableInfo->setFixedHeight( tableInfo->rowHeight( 0 ) * i + 5 );
dlg->layout()->addWidget( tableInfo );
dlg->resize( 600, 250 );
dlg->layout()->addSpacing( 5 );
// gradient file
QString gradientFile = mRamp->info().value( "cpt-city-gradient" );
if ( ! gradientFile.isNull() )
{
QString fileName = gradientFile;
fileName.replace( "<cpt-city>", QgsCptCityArchive::defaultBaseDir() );
if ( ! QFile::exists( fileName ) )
{
fileName = gradientFile;
fileName.replace( "<cpt-city>", "http://soliton.vm.bytemark.co.uk/pub/cpt-city" );
}
label = new QLabel( tr( "Gradient file : %1" ).arg( fileName ), dlg );
label->setTextInteractionFlags( Qt::TextBrowserInteraction );
dlg->layout()->addSpacing( 5 );
dlg->layout()->addWidget( label );
}
// license file
QString licenseFile = mRamp->info().value( "cpt-city-license" );
if ( !licenseFile.isNull() )
{
QString fileName = licenseFile;
fileName.replace( "<cpt-city>", QgsCptCityArchive::defaultBaseDir() );
if ( ! QFile::exists( fileName ) )
{
fileName = licenseFile;
fileName.replace( "<cpt-city>", "http://soliton.vm.bytemark.co.uk/pub/cpt-city" );
}
label = new QLabel( tr( "License file : %1" ).arg( fileName ), dlg );
label->setTextInteractionFlags( Qt::TextBrowserInteraction );
dlg->layout()->addSpacing( 5 );
dlg->layout()->addWidget( label );
if ( QFile::exists( fileName ) )
{
QTextEdit *textEdit = new QTextEdit( dlg );
textEdit->setReadOnly( true );
QFile file( fileName );
if ( file.open( QIODevice::ReadOnly | QIODevice::Text ) )
{
textEdit->setText( file.readAll() );
file.close();
dlg->layout()->addSpacing( 5 );
dlg->layout()->addWidget( textEdit );
dlg->resize( 600, 500 );
}
}
}
dlg->show(); //non modal
}
void DossierEditeur::afficherProfil()
{
try
{
QDialog* window = new QDialog(this);
QGridLayout* lay = new QGridLayout;
QPushButton* ok = new QPushButton("Ok");
window->setWindowTitle("Profil");
window->setFixedSize(400, 400);
QStringList Formation = Dossier::getInstance().ListeCursus();
int j = 1;
QTableWidget* valide = new QTableWidget(1,1,this);
QTableWidget* non_valide = new QTableWidget(1,1,this);
QLabel* valideLabel = new QLabel("Validé :",this);
QLabel* NonvalideLabel = new QLabel("A Valider :",this);
valide->horizontalHeader()->hide();
non_valide->horizontalHeader()->hide();
valide->verticalHeader()->hide();
non_valide->verticalHeader()->hide();
valide->setMaximumSize(50,25);
non_valide->setMaximumSize(50,25);
QTableWidgetItem* ItemValide = new QTableWidgetItem("");
ItemValide->setBackground(Qt::red);
valide->setItem(0,0,ItemValide);
QTableWidgetItem* ItemNonValide = new QTableWidgetItem("");
ItemNonValide ->setBackground(Qt::gray);
non_valide->setItem(0,0,ItemNonValide);
//Tableaus affichant le nombre de crédits obtenu par catégorie
for(QList<QString>::iterator it1 = Formation.begin(); it1 < Formation.end(); ++it1)
{
QMap<QString, unsigned int> ListeProfil = Dossier::getInstance().ListeProfil(*it1);
QStringList P = ListeProfil.keys();
QTableWidget* tab = new QTableWidget(1,ListeProfil.size(),this);
tab->setHorizontalHeaderLabels(P);
tab->setSelectionBehavior(QAbstractItemView::SelectRows);
tab->verticalHeader()->hide();
int i = 0;
for(QList<QString>::iterator it2 = P.begin(); it2 < P.end(); ++it2)
{
QString cr; cr.setNum(ListeProfil[*it2]);
QString creditFormation; creditFormation.setNum(FormationManager::getInstance().getFormation(*it1).getProfil(*it2));
QString credit = cr +QString("(")+creditFormation+QString(")");
QTableWidgetItem* monItem = new QTableWidgetItem(credit);
if(FormationManager::getInstance().isFinished(*it1,*it2,ListeProfil[*it2]))
monItem->setBackground(Qt::red);
else
monItem->setBackground(Qt::gray);
tab->setItem(0,i,monItem);
i++;
}
QLabel* form = new QLabel(*it1,this);
lay->addWidget(form,j,0,1,3,Qt::AlignLeft);
lay->addWidget(tab,j,1,1,3,Qt::AlignJustify);
j++;
}
lay->addWidget(valideLabel,0,0);
lay->addWidget(valide,0,1);
lay->addWidget(NonvalideLabel,0,2);
lay->addWidget(non_valide,0,3);
lay->addWidget(ok,j,1,Qt::AlignHCenter);
window->setLayout(lay);
connect(ok,SIGNAL(clicked()),window,SLOT(accept()));
window->exec();
if(window->result())
{
}
}
catch(UTProfilerException& e)
{
QMessageBox::warning(this, "Ajout d'inscription", e.getInfo());
}
}
void FenPrincipale::calcul_general() {
QString html = "<table>\n\t<thead>\n\t\t<tr>\n\t\t\t";
html += "<td>"+tr("Position")+"</td>";
html += "<td>"+tr("Équipage")+"</td>";
html += "<td>"+tr("Points")+"</td>";
for (int j = 0; j < this->nbManches; ++j) {
html += "<td>"+tr("M")+QString::number(j+1)+"</td>";
}
html += "\n\t\t</tr>\n\t</thead>\n\t<tboby>";
QTableWidget *table = new QTableWidget();
table->verticalHeader()->hide();
table->setSelectionMode(QAbstractItemView::NoSelection);
table->setColumnCount(3+this->nbManches);
table->setRowCount(this->nbEquipages);
table->setColumnWidth(0, 80);
table->setColumnWidth(1, 200);
table->setColumnWidth(2, 60);
int size = 80 + 200 + 60;
QList<QString> labels;
labels << tr("Position") << tr("Équipage") << tr("Points");
for (int j = 0; j < this->nbManches; ++j) {
labels << tr("M")+QString::number(j+1);
size += 50;
table->setColumnWidth(3+j, 50);
}
table->setMinimumWidth(size + 20);
table->setMaximumWidth(size + 20);
table->setHorizontalHeaderLabels(labels);
ui->resultatsLayout->insertWidget(0, table);
for (int i = 0; i < this->nbEquipages; ++i) {
QList<int> ids;
Equipage e1;
for (int k = 0; k < this->nbEquipages; ++k) {
Equipage e2 = this->equipages[k];
if (e2.points <= 0) {
// cet équipage a déjà été affiché
continue;
}
if (ids.isEmpty() || e2.points < e1.points) {
ids.clear();
ids.append(k);
e1 = e2;
}
else if (e2.points == e1.points) {
// égalité de points
// pour départager les équipages, on confronte leurs meilleures
// manches (sans celles retirées)
for (int j = 0; j < e1.pointsTries.size(); ++j) {
if (e2.pointsTries[j] < e1.pointsTries[j]) {
ids.clear();
ids.append(k);
e1 = e2;
break;
}
else if (e2.pointsTries[j] > e1.pointsTries[j]) {
break;
}
else if (j == e1.pointsTries.size()-1) {
// égalité des manches
// pour départager les équipages, on confronte toutes
// leur manches dans l'ordre en partant de la dernière
for (int l = 0; l < e1.pointsOrdonnes.size(); ++l) {
if (e2.pointsOrdonnes[l] < e1.pointsOrdonnes[l]) {
ids.clear();
ids.append(k);
e1 = e2;
break;
}
else if (e2.pointsOrdonnes[l] > e1.pointsOrdonnes[l]) {
break;
}
else if (l == e1.pointsOrdonnes.size()-1) {
// égalité parfaite
ids.append(k);
}
}
}
}
}
}
for (int k = 0; k < ids.size(); ++k) {
Equipage e = this->equipages[ids[k]];
// on ajoute le début de la table html
// on rajoute les manches en parallèle à causes de celles retirées
QString nomString = "<span class=\"equipage\">"+e.nom+"</span>";
if (this->typeClmt == CLMT_TEMPS) {
nomString += "<span class=\"bateau\">"
+this->bateaux.value(e.rating.toUpper()).serie
+" ("+QString::number(e.coef)+")</span>";
}
html += "\n\t\t<tr>\n\t\t\t<td>"+QString::number(i+1)+"</td>"
+"<td>"+nomString+"</td>"
+"<td>"+QString::number(e.points)+"</td>";
// on ajout l'équipage
QLabel *pos = new QLabel(QString::number(i+1));
QWidget *nomWidget = new QWidget();
QVBoxLayout *nomLayout = new QVBoxLayout();
QLabel *nom = new QLabel(e.nom);
nom->setProperty("label", "nom");
nomLayout->addWidget(nom);
if (this->typeClmt == CLMT_TEMPS) {
QLabel *bateau = new QLabel();
bateau->setText(this->bateaux.value(e.rating.toUpper()).serie
+" ("+QString::number(e.coef)+")");
bateau->setProperty("label", "bateau");
nomLayout->addWidget(bateau);
table->setRowHeight(i+k, 45);
}
nomLayout->setContentsMargins(0, 0, 0, 0);
nomLayout->setSpacing(0);
nomWidget->setLayout(nomLayout);
QLabel *points = new QLabel(QString::number(e.points));
table->setCellWidget(i+k, 0, pos);
table->setCellWidget(i+k, 1, nomWidget);
table->setCellWidget(i+k, 2, points);
for (int j = 0; j < this->nbManches; ++j) {
Manche m = e.manches[j];
QLabel *la = new QLabel();
if (m.tpsCompense < 0) {
la->setText(this->get_abr(m.abr));
}
else {
la->setText(QString::number(m.points));
}
for (int l = 0; l < e.pointsRetires.size(); ++l) {
if (e.pointsRetires[l] == m.points) {
la->setText("("+la->text()+")");
e.pointsRetires.removeAt(l);
break;
}
}
html += "<td>"+la->text()+"</td>";
table->setCellWidget(i+k, j+3, la);
}
html += "\n\t\t</tr>";
this->equipages[ids[k]].points = 0;
}
i += ids.size()-1;
}
html += "\n\t</tbody>\n</table>";
this->htmls.prepend(html);
this->progression(95);
}
void Table::setRowHeight(int row, int min_size, int max_size)
{
QTableWidget *tablewidget = static_cast<QTableWidget*>(getQWidget());
tablewidget->verticalHeader()->setMinimumSectionSize(min_size);
tablewidget->verticalHeader()->setMaximumSectionSize(max_size);
}
void PublicTalks::beforeSpeakerShown(QString name, cPersonComboBox *c)
{
//cPersonComboBox *c = combo;
// get speakers for comboBox
//cPersonComboBox *combo = static_cast<cPersonComboBox *>(maintable->cellWidget(combo->property("currentrow").toInt(),3));
cPersonComboBox *themeCombo = static_cast<cPersonComboBox *>(maintable->cellWidget(c->property("currentrow").toInt(),2));
qDebug() << "currentRow1:" << c->currentText() << "rownumber:" << c->property("currentrow") << name;
if (c) {
qDebug() << "combo ok";
} else {
qDebug() << "combo false";
}
QTableWidget *table = new QTableWidget(0,4);
table->setColumnHidden(0,true);
table->setColumnWidth(3,0);
std::vector<sql_item> speakers;
if(themeCombo->currentText() == "") {
// ei teemaa valittu
speakers = sql.selectSql("SELECT henkilot.*,yleisokokous.pvm "
"FROM henkilot "
"LEFT JOIN yleisokokous ON henkilot.id = yleisokokous.puhuja_id "
"WHERE henkilot.ohjelmatyypit & 512 GROUP BY henkilot.id ORDER BY nimi");
} else {
// teema valittu --> haetaan teeman sopivat puhujat
speakers = sql.selectSql("SELECT henkilot.*,P_Esitelmat.aihe_id,yleisokokous.pvm "
"FROM henkilot "
"LEFT JOIN P_Esitelmat ON henkilot.id = P_Esitelmat.puhuja_id "
"LEFT JOIN yleisokokous ON henkilot.id = yleisokokous.puhuja_id "
" WHERE P_Esitelmat.aihe_id = '" +
QString::number(getThemeId(themeCombo->currentText())) +
"' AND henkilot.ohjelmatyypit & 512 GROUP BY henkilot.id ORDER BY nimi, etunimi");
}
table->setRowCount(speakers.size()+1);
int currentRow = 0;
for(unsigned int i = 0; i < speakers.size(); i++) {
table->setItem(i+1,0,new QTableWidgetItem( speakers[i].getValue("id") ));
table->setItem(i+1,1,new QTableWidgetItem( speakers[i].getValue("nimi") + ", " + speakers[i].getValue("etunimi")) );
table->setItem(i+1,2,new QTableWidgetItem( speakers[i].getValue("pvm")) );
table->setItem(i+1,3,new QTableWidgetItem( speakers[i].getValue("etunimi") + " " + speakers[i].getValue("nimi")) );
if(c->currentText() == table->item(i+1,3)->text()) {
QFont boldfont(table->item(i+1,1)->font().family(),
table->item(i+1,1)->font().pointSize(),
QFont::Bold);
table->item(i+1,1)->setFont(boldfont);
currentRow = i+1;
}
}
table->verticalHeader()->hide();
table->setColumnWidth(1,150);
table->setColumnWidth(2,100);
table->setMinimumWidth(280);
c->clear();
c->setModel(table->model());
c->setView(table);
c->setModelColumn(1);
c->setCurrentIndex(currentRow);
table->setSortingEnabled(true);
table->sortByColumn(1,Qt::AscendingOrder);
}
void TSController::processDataParams(){
// qDebug()<<"TSController::processDataParams";
qDebug()<<"this is result button !";
QTableWidget *qtw = ui->resultsTable;
qtw->setColumnCount(2);
qtw->setRowCount(12);
qtw->verticalHeader()->setVisible(false);
qtw->setHorizontalHeaderLabels(QString(tr("Параметр;Значение")).split(";"));
qtw->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
/* tsanalitics* ga = new tsanalitics();
tstempanalitic* gao = new tstempanalitic();
tstempanalitic* gai = new tstempanalitic();*/
float AvgExpirationSpeed=0, MaxExpirationSpeed=0, AvgExpirationTime=0, AvgInspirationTime=0,
AvgRoundTime=0, AvgTempIn=0, AvgTempOut=0, AvgTempInMinusAvgTempOut=0, BreathingVolume=0, MVL=0, MinuteVentilation=0;
float InspirationFrequency=0;
int *vo = curveBuffer->volume();
int *ti = curveBuffer->tempIn();
int *to = curveBuffer->tempOut();
QVector<int> volume,temp_in,temp_out;
for(int i=0;i<curveBuffer->getLenght();i++){
volume.push_back(vo[i]);
temp_in.push_back(ti[i]);
temp_out.push_back(to[i]);
}
VolumeSolver* vs = new VolumeSolver(volume,temp_in,temp_out);
AvgExpirationSpeed = vs->getAverageExpirationSpeed();
qtw->setItem(1,0,getQTableWidgetItem(tr("Средняя скорость выдоха(л/с)")));
qtw->setItem(1,1,getQTableWidgetItem(QString::number(fabs(curveBuffer->volToLtr((int)AvgExpirationSpeed)))));
MaxExpirationSpeed = vs->getMaxExpirationSpeed();
qtw->setItem(2,0,getQTableWidgetItem(tr("Максимальная скорость выдоха(л/с)")));
qtw->setItem(2,1,getQTableWidgetItem(QString::number(fabs(curveBuffer->volToLtr((int)MaxExpirationSpeed)))));
AvgExpirationTime = vs->getAverageExpirationTime();
qtw->setItem(3,0,getQTableWidgetItem(tr("Среднее время выдоха(с)")));
qtw->setItem(3,1,getQTableWidgetItem((QString::number((float)AvgExpirationTime))));
AvgInspirationTime = vs->getAverageInspirationTime();
qtw->setItem(4,0,getQTableWidgetItem(tr("Среднее время вдоха(с)")));
qtw->setItem(4,1,getQTableWidgetItem((QString::number((float)AvgInspirationTime))));
AvgRoundTime = vs->getAverageCycleTime();
qtw->setItem(5,0,getQTableWidgetItem(tr("Средняя время цикла(с)")));
qtw->setItem(5,1,getQTableWidgetItem((QString::number((float)AvgRoundTime))));
InspirationFrequency = vs->getInspirationFrequancyInOneMinute();
qtw->setItem(6,0,getQTableWidgetItem(tr("Частота дыхания(ед/мин)")));
qtw->setItem(6,1,getQTableWidgetItem((QString::number(InspirationFrequency))));
MinuteVentilation = vs->getMinuteVentilation();
qtw->setItem(8,0,getQTableWidgetItem(tr("Минутная вентиляция легких(л)")));
qtw->setItem(8,1,getQTableWidgetItem(QString::number(curveBuffer->volToLtr(MinuteVentilation))));
BreathingVolume = vs->getAverageInspiratonVentilation();
qtw->setItem(7,0,getQTableWidgetItem(tr("Дыхательный объем(л)")));
qtw->setItem(7,1,getQTableWidgetItem(QString::number(fabs(curveBuffer->volToLtr((int)BreathingVolume)))));
MVL = vs->getTotalVentilation();
qtw->setItem(9,0,getQTableWidgetItem(tr("Суммарная вентиляция легких(л)")));
qtw->setItem(9,1,getQTableWidgetItem(QString::number(fabs(curveBuffer->volToLtr((int)MVL)))));
//ga->clear();
AvgTempIn = vs->getAverageInspirationTempetature();
qtw->setItem(10,0,getQTableWidgetItem(tr("Средняя температура вдоха( 'C)")));
qtw->setItem(10,1,getQTableWidgetItem(QString::number(curveBuffer->tempInToDeg(AvgTempIn))));
//gai->clear();
AvgTempOut = vs->getAverageExpirationTempetature();
qtw->setItem(11,0,getQTableWidgetItem(tr("Средняя температура выдоха( 'C)")));
qtw->setItem(11,1,getQTableWidgetItem(QString::number(curveBuffer->tempOutToDeg(AvgTempOut))));
AvgTempInMinusAvgTempOut = AvgTempOut-AvgTempIn;
qtw->setItem(12,0,getQTableWidgetItem(tr("Средняя Твдоха-Средняя Твыдоха( 'C)")));
qtw->setItem(12,1,getQTableWidgetItem(curveBuffer->tempOutToDeg(AvgTempOut)-curveBuffer->tempInToDeg(AvgTempIn)));
qtw->removeRow(0);
qtw->show();
delete vs;
}
void MainWindow::on_actionShortcuts_triggered() {
QTableWidget* scTable = new QTableWidget();
scTable->setRowCount(0);
scTable->setColumnCount(2);
scTable->setHorizontalHeaderItem(0, new QTableWidgetItem("Shortcut"));
scTable->setHorizontalHeaderItem(1, new QTableWidgetItem("Description"));
scTable->verticalHeader()->hide();
QLinkedList<QPair<QString, QString>> scList;
//read from file in resources and add to linked list
QFile shortcutFile(":Shortcuts/resources/shortcuts.txt");
if (!shortcutFile.open(QIODevice::ReadOnly | QIODevice::Text))
return;
QString line;
while (!shortcutFile.atEnd()) {
QTextStream stream(&shortcutFile);
while (!stream.atEnd()) {
line = stream.readLine();
QStringList shortCutAndDescription = line.split(':');
if (shortCutAndDescription.size() == 2) {
scList.append(QPair<QString, QString>(shortCutAndDescription[0], shortCutAndDescription[1]));
}
}
}
QLinkedList<QPair<QString, QString>>::const_iterator sc;
for (sc = scList.constBegin(); sc != scList.constEnd(); ++sc) {
scTable->insertRow(scTable->rowCount());
QTableWidgetItem* scKey = new QTableWidgetItem(sc->first);
QTableWidgetItem* scKeyInfo = new QTableWidgetItem(sc->second);
scKey->setFlags(Qt::NoItemFlags | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
scKeyInfo->setFlags(Qt::NoItemFlags | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
scTable->setItem(scTable->rowCount() - 1, 0, scKey);
scTable->setItem(scTable->rowCount() - 1, 1, scKeyInfo);
}
//scTable->horizontalHeader()->setStretchLastSection( true );
scTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
QWidget* outerWidget = new QWidget();
outerWidget->setWindowTitle("Shortcuts");
outerWidget->resize(scTable->size());
QVBoxLayout* vLayout = new QVBoxLayout();
vLayout->addWidget(scTable);
outerWidget->setLayout(vLayout);
outerWidget->show();
}
void TSController::processDataParams(){
TSCurveBuffer *cb= new TSCurveBuffer;
readerThread->readd();
//TSUsb3000Reader *rdr= readerThread->getReader();
//rdr->read();
//rdr->initDevice(cb);
/*rdr->read();*/
qDebug()<<"this is result button !";
QTableWidget *qtw = ui->resultsTable;
qtw->setColumnCount(2);
qtw->setRowCount(11);
qtw->verticalHeader()->setVisible(false);
qtw->setHorizontalHeaderLabels(QString(tr("Параметр;Значение")).split(";"));
qtw->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
tsanalitics* ga = new tsanalitics();
tstempanalitic* gao = new tstempanalitic();
tstempanalitic* gai = new tstempanalitic();
int AvgExpirationSpeed=0, MaxExpirationSpeed=0, AvgExpirationTime=0, AvgInspirationTime=0,
AvgRoundTime=0, AvgTempIn=0, AvgTempOut=0, AvgTempInMinusAvgTempOut=0, BreathingVolume=0, MVL=0;
float InspirationFrequency=0;
int i=0;
int *vo = curveBuffer->volume();
for(i=0;i<curveBuffer->getLenght();i++){
ga->append(vo[i]);
}
ga->approximate();
int *ti = curveBuffer->tempIn();
for(i=0;i<curveBuffer->getLenght();i++){
gai->append(ti[i]);
}
gai->findExtremums();
gai->deleteBadExtremums();
int *to = curveBuffer->tempOut();
for(i=0;i<curveBuffer->getLenght();i++){
gao->append(to[i]);
}
gao->findExtremums();
gao->deleteBadExtremums();
AvgExpirationSpeed = ga->getAvgExpiratorySpeed();
qtw->setItem(1,0,getQTableWidgetItem(tr("Средняя скорость выдоха(л/с)")));
qtw->setItem(1,1,getQTableWidgetItem(QString::number(fabs(curveBuffer->volToLtr(AvgExpirationSpeed)))));
MaxExpirationSpeed = ga->getMaxExpiratorySpeed();
qtw->setItem(2,0,getQTableWidgetItem(tr("Максимальная скорость выдоха(л/с)")));
qtw->setItem(2,1,getQTableWidgetItem(QString::number(fabs(curveBuffer->volToLtr(100*MaxExpirationSpeed)))));
AvgExpirationTime = ga->getAvgExpiratoryTime();
qtw->setItem(3,0,getQTableWidgetItem(tr("Среднее время выдоха(с)")));
qtw->setItem(3,1,getQTableWidgetItem((QString::number((float)AvgExpirationTime/100))));
AvgInspirationTime = ga->getAvgInspiratoryTime();
qtw->setItem(4,0,getQTableWidgetItem(tr("Среднее время вдоха(с)")));
qtw->setItem(4,1,getQTableWidgetItem((QString::number((float)AvgInspirationTime/100))));
AvgRoundTime = AvgExpirationTime+AvgInspirationTime;
qtw->setItem(5,0,getQTableWidgetItem(tr("Средняя время цикла(с)")));
qtw->setItem(5,1,getQTableWidgetItem((QString::number((float)AvgRoundTime/100))));
InspirationFrequency = ga->getFrequency();
qtw->setItem(6,0,getQTableWidgetItem(tr("Частота дыхания(ед/мин)")));
qtw->setItem(6,1,getQTableWidgetItem((QString::number(InspirationFrequency))));
BreathingVolume = ga->getBreathingVolume();
qtw->setItem(7,0,getQTableWidgetItem(tr("Дыхательный объем(л)")));
qtw->setItem(7,1,getQTableWidgetItem(QString::number(fabs(curveBuffer->volToLtr(BreathingVolume)))));
MVL = ga->getMVL();
qtw->setItem(8,0,getQTableWidgetItem(tr("Максимальная вентиляция легких(л)")));
qtw->setItem(8,1,getQTableWidgetItem(QString::number(fabs(curveBuffer->volToLtr(MVL)))));
ga->clear();
AvgTempIn = gai->getMinAvgs();
qtw->setItem(9,0,getQTableWidgetItem(tr("Средняя температура вдоха( 'C)")));
qtw->setItem(9,1,getQTableWidgetItem(QString::number(curveBuffer->tempInToDeg(AvgTempIn))));
gai->clear();
AvgTempOut = gao->getMaxAvgs();
qtw->setItem(10,0,getQTableWidgetItem(tr("Средняя температура выдоха( 'C)")));
qtw->setItem(10,1,getQTableWidgetItem(QString::number(curveBuffer->tempOutToDeg(AvgTempOut))));
AvgTempInMinusAvgTempOut = AvgTempOut-AvgTempIn;
qtw->setItem(11,0,getQTableWidgetItem(tr("Средняя Твдоха-Средняя Твыдоха( 'C)")));
qtw->setItem(11,1,getQTableWidgetItem(curveBuffer->tempOutToDeg(AvgTempOut)-curveBuffer->tempInToDeg(AvgTempIn)));
qtw->removeRow(0);
qtw->show();
}
void InfoDialog::setupUi(const Tags &tags)
{
int row = 0;
QVBoxLayout *layout = new QVBoxLayout;
layout->setContentsMargins(0,0,0,0);
setWindowTitle(tr("EXIF information"));
if (!tags.fileName().isEmpty())
setWindowTitle(windowTitle() + " - " + QFileInfo(tags.fileName()).fileName());
setWindowIcon(QIcon(":images/exif_info"));
if (tags.size())
{
QMapIterator<int, QPair<Tag, Data> > tag(tags);
QTableWidget *tableWidget = new QTableWidget(tags.size(),2,this);
tableWidget->setAlternatingRowColors(true);
tableWidget->verticalHeader()->setVisible(false);
tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
tableWidget->setSelectionMode(QAbstractItemView::NoSelection);
tableWidget->setHorizontalHeaderItem(0,new QTableWidgetItem(tr("Tag")));
tableWidget->setHorizontalHeaderItem(1,new QTableWidgetItem(tr("Value")));
tableWidget->horizontalHeader()->setStretchLastSection(true);
while (tag.hasNext())
{
QTableWidgetItem *item;
QPair<Tag,Data> exifValue = tag.next().value();
item = new QTableWidgetItem(exifValue.first.title);
item->setToolTip(exifValue.first.description.split(". ",QString::SkipEmptyParts).join("\n"));
tableWidget->setItem(row,0,item);
item = new QTableWidgetItem(exifValue.second.readableValue);
item->setToolTip(exifValue.first.description.split(". ",QString::SkipEmptyParts).join("\n"));
tableWidget->setItem(row++,1,item);
}
tableWidget->resizeColumnsToContents();
tableWidget->resizeRowsToContents();
layout->addWidget(tableWidget);
}
else
{
QLabel *label = new QLabel(tr("No EXIF information available"),this);
label->setAlignment(Qt::AlignCenter);
layout->addWidget(label);
}
#ifdef Q_WS_MAC
QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok,Qt::Horizontal,this);
connect(buttonBox,SIGNAL(accepted()),this,SLOT(close()));
layout->addWidget(buttonBox);
#endif
setLayout(layout);
resize(600,400);
}
ValidationResultDialog::ValidationResultDialog(ValidationItem* item)
{
//return if there's no parent
if (item == NULL)
{
return;
}
QDialogButtonBox* buttons = new QDialogButtonBox(QDialogButtonBox::Ok,Qt::Horizontal, this);
QPushButton* print_button = new QPushButton("Save to File", buttons);
QVBoxLayout* mainLayout = new QVBoxLayout();
QGroupBox* resultGroup = new QGroupBox(tr("Validation Results"),this);
QGridLayout* layout = new QGridLayout();
QVBoxLayout* resultGroupLayout = new QVBoxLayout();
int type = item->getValidationType();
if (type < 4 || type==5)
{
String train_fit ="R^2";
String pred_qual="Q^2";
String n = item->modelItem()->getRegistryEntry()->getStatName(item->getValidationStatistic());
if(n!="")
{
train_fit = n+"<br>on training data";
pred_qual = "predictive<br>"+n;
}
QLabel* rlabel = new QLabel(train_fit.c_str(),this);
layout->addWidget(rlabel, 0,1);
QString tmp;
QLabel* qlabel=NULL;
if(type<3)
{
qlabel = new QLabel(tmp.setNum(item->k())+ " fold "+pred_qual.c_str(),this);
}
else if(type==3) // boostrap
{
qlabel = new QLabel(QString(pred_qual.c_str())+" of "+tmp.setNum(item->numOfSamples())+ "\nbootstrap samples",this);
}
else if(type==5)
{
qlabel = new QLabel(tmp.setNum(item->getNoExternalFolds())+ " fold nested "+pred_qual.c_str(),this);
}
layout->addWidget(qlabel, 0,2);
QLabel* rvaluelabel = new QLabel(QString(((String)(item->getR2())).c_str()),this);
layout->addWidget(rvaluelabel,1,1);
QLabel* qvaluelabel = new QLabel(QString(((String)(item->getQ2())).c_str()),this);
layout->addWidget(qvaluelabel,1,2);
resultGroup->setLayout(layout);
}
else if (type == 4)
{
QString value;
float num;
QStringList labels;
labels << "# Tests" << "R^2" << "Q^2";
QTableWidget* table = new QTableWidget(item->resultOfRandTest()->rows(), 3, this);
table->verticalHeader()->hide();
table->setHorizontalHeaderLabels (labels);
table->setAlternatingRowColors(true);
table->setDragDropMode(QAbstractItemView::NoDragDrop);
table->setEditTriggers(QAbstractItemView::NoEditTriggers);
table->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
table->horizontalHeader()->setResizeMode(2,QHeaderView::Stretch);
for (int i = 0; i < item->resultOfRandTest()->rows();i++)
{
value.setNum(i);
QTableWidgetItem* num_of_Test = new QTableWidgetItem(value);
table->setItem(i, 0, num_of_Test);
num = (*(item->resultOfRandTest()))(i,item->resultOfRandTest()->cols()-2);
value.setNum(num);
QTableWidgetItem* r = new QTableWidgetItem(value);
table->setItem(i, 1, r);
num = (*(item->resultOfRandTest()))(i,item->resultOfRandTest()->cols()-1);
value.setNum(num);
QTableWidgetItem* q = new QTableWidgetItem(value);
table->setItem(i, 2, q);
}
QScrollArea* scrollArea = new QScrollArea(this);
scrollArea->setHorizontalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
scrollArea->setVerticalScrollBarPolicy ( Qt::ScrollBarAsNeeded );
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setWidget(table);
scrollArea->setWidgetResizable(true);
resultGroupLayout->addWidget(scrollArea);
resultGroup->setLayout(resultGroupLayout);
}
mainLayout->addWidget(resultGroup);
mainLayout->addWidget(buttons);
mainLayout->addStretch(1);
setLayout(mainLayout);
setWindowTitle("Validation Results for " + item->name());
connect(buttons, SIGNAL(accepted()), this, SLOT(accept()));
connect(print_button, SIGNAL(clicked()), this, SLOT(saveToFile()));
}