ActivateModsDialog::ActivateModsDialog(const std::map<QString, std::vector<QString> > &missingPlugins, QWidget *parent)
: TutorableDialog("ActivateMods", parent), ui(new Ui::ActivateModsDialog)
{
ui->setupUi(this);
QTableWidget *modsTable = findChild<QTableWidget*>("modsTable");
QHeaderView *headerView = modsTable->horizontalHeader();
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
headerView->setSectionResizeMode(0, QHeaderView::Stretch);
headerView->setSectionResizeMode(1, QHeaderView::Interactive);
#else
headerView->setResizeMode(0, QHeaderView::Stretch);
headerView->setResizeMode(1, QHeaderView::Interactive);
#endif
int row = 0;
modsTable->setRowCount(missingPlugins.size());
for (std::map<QString, std::vector<QString> >::const_iterator espIter = missingPlugins.begin();
espIter != missingPlugins.end(); ++espIter, ++row) {
modsTable->setCellWidget(row, 0, new QLabel(espIter->first));
if (espIter->second.size() == 0) {
modsTable->setCellWidget(row, 1, new QLabel(tr("not found")));
} else {
QComboBox* combo = new QComboBox();
for (std::vector<QString>::const_iterator modIter = espIter->second.begin();
modIter != espIter->second.end(); ++modIter) {
combo->addItem(*modIter);
}
modsTable->setCellWidget(row, 1, combo);
}
}
}
void ItemTagsLoader::addTagToSettingsTable(const ItemTagsLoader::Tag &tag)
{
QTableWidget *t = ui->tableWidget;
const int row = t->rowCount();
t->insertRow(row);
t->setItem( row, tagsTableColumns::name, new TagTableWidgetItem(tag.name) );
t->setItem( row, tagsTableColumns::match, new QTableWidgetItem(tag.match) );
t->setItem( row, tagsTableColumns::styleSheet, new QTableWidgetItem(tag.styleSheet) );
t->setItem( row, tagsTableColumns::color, new QTableWidgetItem() );
t->setItem( row, tagsTableColumns::icon, new QTableWidgetItem() );
auto colorButton = new QPushButton(t);
const QColor color = tag.color.isEmpty()
? QColor::fromRgb(50, 50, 50)
: deserializeColor(tag.color);
setColorIcon(colorButton, color);
t->setCellWidget(row, tagsTableColumns::color, colorButton);
connect(colorButton, &QAbstractButton::clicked, this, &ItemTagsLoader::onColorButtonClicked);
auto iconButton = new IconSelectButton(t);
iconButton->setCurrentIcon(tag.icon);
t->setCellWidget(row, tagsTableColumns::icon, iconButton);
connect(iconButton, &IconSelectButton::currentIconChanged, this, &ItemTagsLoader::onAllTableWidgetItemsChanged);
onTableWidgetItemChanged(t->item(row, 0));
}
HttpUserSetupDialog::HttpUserSetupDialog(QWidget *parent)
: QDialog(parent)
, ui(new Ui::HttpUserSetupDialog)
{
ui->setupUi(this);
QTableWidget * tableWidget = ui->httpUsers;
QList<HttpUser*> users = HttpUserUtil::instance()->users();
tableWidget->setRowCount(users.size());
int row = 0;
foreach(HttpUser *user, users)
{
tableWidget->setItem(row, 0, new QTableWidgetItem(user->user()));
tableWidget->setItem(row, 1, new QTableWidgetItem(user->pass()));
tableWidget->setItem(row, 2, new QTableWidgetItem(QString::number(user->level())));
QComboBox *levelCombo = new QComboBox();
levelCombo->addItems(QStringList() << "Guest" << "User" << "Admin");
levelCombo->setCurrentIndex(user->level());
tableWidget->setCellWidget(row, 2, levelCombo);
row ++;
}
void ShortcutsWidget::addShortcutRow(MenuAction &action)
{
QTableWidget *table = ui->tableWidget;
const int row = table->rowCount();
table->insertRow(row);
auto tableItem = new QTableWidgetItem();
action.tableItem = tableItem;
table->setItem(row, Columns::Icon, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
tableItem = new QTableWidgetItem(uiText(action.text));
table->setItem(row, Columns::Text, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
tableItem = new QTableWidgetItem();
table->setItem(row, Columns::Type, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
if (action.command.type() & CommandType::GlobalShortcut) {
tableItem->setIcon( getIcon("", IconExternalLinkSquareAlt) );
tableItem->setToolTip( tr("Shortcut can be triggered from any application") );
}
action.shortcutButton = new ShortcutButton(table);
table->setCellWidget(row, Columns::Shortcut, action.shortcutButton);
m_actions.append(action);
connect( action.shortcutButton, &ShortcutButton::shortcutAdded,
this, &ShortcutsWidget::onShortcutAdded );
connect( action.shortcutButton, &ShortcutButton::shortcutRemoved,
this, &ShortcutsWidget::onShortcutRemoved );
}
QWidget *ItemSyncLoader::createSettingsWidget(QWidget *parent)
{
ui.reset(new Ui::ItemSyncSettings);
QWidget *w = new QWidget(parent);
ui->setupUi(w);
// Init tab sync path table.
const QStringList tabPaths = m_settings.value(configSyncTabs).toStringList();
QTableWidget *t = ui->tableWidgetSyncTabs;
for (int row = 0, i = 0; i < tabPaths.size() + 20; ++row, i += 2) {
t->insertRow(row);
t->setItem( row, syncTabsTableColumns::tabName, new QTableWidgetItem(tabPaths.value(i)) );
t->setItem( row, syncTabsTableColumns::path, new QTableWidgetItem(tabPaths.value(i + 1)) );
QPushButton *button = createBrowseButton();
t->setCellWidget(row, syncTabsTableColumns::browse, button);
connect( button, &QAbstractButton::clicked,
this, &ItemSyncLoader::onBrowseButtonClicked );
}
setNormalStretchFixedColumns(t, syncTabsTableColumns::tabName, syncTabsTableColumns::path,
syncTabsTableColumns::browse);
// Init file format table.
const QVariantList formatSettings = m_settings.value(configFormatSettings).toList();
t = ui->tableWidgetFormatSettings;
for (int row = 0; row < formatSettings.size() + 10; ++row) {
const QVariantMap format = formatSettings.value(row).toMap();
const QString formats = format.value("formats").toStringList().join(", ");
t->insertRow(row);
t->setItem( row, formatSettingsTableColumns::formats, new QTableWidgetItem(formats) );
t->setItem( row, formatSettingsTableColumns::itemMime, new QTableWidgetItem(format.value("itemMime").toString()) );
auto button = new IconSelectButton();
button->setCurrentIcon( format.value("icon").toString() );
t->setCellWidget(row, formatSettingsTableColumns::icon, button);
}
setNormalStretchFixedColumns(t, formatSettingsTableColumns::formats,
formatSettingsTableColumns::itemMime,
formatSettingsTableColumns::icon);
return w;
}
void ShortcutsWidget::loadShortcuts(QSettings &settings)
{
MenuItems items = menuItems();
::loadShortcuts(&items, settings);
m_actions.clear();
m_shortcuts.clear();
QTableWidget *table = ui->tableWidget;
while (table->rowCount() > 0)
table->removeRow(0);
foreach (const MenuItem &item, items) {
MenuAction action;
action.iconName = item.iconName;
action.iconId = item.iconId;
action.text = item.text;
action.settingsKey = item.settingsKey;
const int row = table->rowCount();
table->insertRow(row);
QTableWidgetItem *tableItem = new QTableWidgetItem();
table->setItem(row, Columns::Empty, tableItem);
tableItem->setFlags(Qt::NoItemFlags);
tableItem = new QTableWidgetItem();
action.tableItem = tableItem;
table->setItem(row, Columns::Icon, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
tableItem = new QTableWidgetItem(uiText(action.text));
table->setItem(row, Columns::Text, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
action.shortcutButton = new ShortcutButton(table);
table->setCellWidget(row, Columns::Shortcut, action.shortcutButton);
action.shortcutButton->setDefaultShortcut(item.defaultShortcut);
foreach (const QKeySequence &shortcut, item.shortcuts)
action.shortcutButton->addShortcut(shortcut);
action.iconId = item.iconId;
m_actions.append(action);
m_shortcuts << item.shortcuts;
m_timerCheckAmbiguous.start();
connect( action.shortcutButton, SIGNAL(shortcutAdded(QKeySequence)),
this, SLOT(onShortcutAdded(QKeySequence)) );
connect( action.shortcutButton, SIGNAL(shortcutRemoved(QKeySequence)),
this, SLOT(onShortcutRemoved(QKeySequence)) );
}
/**
* @brief Updates the resolver pool display.
*/
void OpenNIC::updateResolverPool(QStringList resolverPool)
{
/* @brief <status>;<score>;<kind>;<hostAddress>; */
QTableWidget* table = ui->resolverPoolTable;
double minScore,maxScore;
scoreMinMax(resolverPool, minScore, maxScore);
table->setRowCount(resolverPool.count());
for(int row=0; row < resolverPool.count(); row++ )
{
QStringList elements = resolverPool.at(row).split(";");
QString ip = elements.at(3);
QString kind = elements.at(2);
QString score = elements.at(1);
QString status = elements.at(0);
QString statusIcon;
if (status == "R")
{
status = tr("FAIL");
statusIcon = ":/images/status-red.png";
}
else if (status == "G")
{
status = tr("OK");
statusIcon = ":/images/status-green.png";
}
else if (status == "Y")
{
status = tr("WARN");
statusIcon = ":/images/status-yellow.png";
}
table->setItem(row,3,new QTableWidgetItem(ip));
table->setItem(row,2,new QTableWidgetItem(kind));
#if 0
table->setItem(row,1,new QTableWidgetItem(score));
#else
QProgressBar* bar = new QProgressBar();
bar->setRange((int)(minScore*1000.0),(int)(maxScore*1000.0));
bar->setValue((int)(score.toDouble()*1000.0));
table->setCellWidget(row,1,bar);
#endif
table->setItem(row,0,new QTableWidgetItem(QIcon(statusIcon),status));
}
table->resizeColumnsToContents();
table->resizeRowsToContents();
table->setSortingEnabled(true);
table->sortByColumn(1,Qt::DescendingOrder);
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QTableWidget tableWidget;
// tableWidget.setAttribute(Qt::WA_StaticContents);
tableWidget.viewport()->setAttribute(Qt::WA_StaticContents);
tableWidget.setRowCount(15);
tableWidget.setColumnCount(4);
for (int row = 0; row < 15; ++row)
for (int col = 0; col < 4; ++col)
// tableWidget.setCellWidget(row, col, new StaticWidget());
tableWidget.setCellWidget(row, col, new CellWidget());
tableWidget.resize(400, 600);
tableWidget.show();
return app.exec();
}
/** Loads the settings for this page */
void ShareManager::load()
{
if(isLoading)
return ;
isLoading = true;
// std::cerr << "ShareManager:: In load !!!!!" << std::endl ;
std::list<SharedDirInfo>::const_iterator it;
std::list<SharedDirInfo> dirs;
rsFiles->getSharedDirectories(dirs);
/* get a link to the table */
QTableWidget *listWidget = ui.shareddirList;
/* set new row count */
listWidget->setRowCount(dirs.size());
int row=0 ;
for(it = dirs.begin(); it != dirs.end(); ++it,++row)
{
listWidget->setItem(row, COLUMN_PATH, new QTableWidgetItem(QString::fromUtf8((*it).filename.c_str())));
listWidget->setItem(row, COLUMN_VIRTUALNAME, new QTableWidgetItem(QString::fromUtf8((*it).virtualname.c_str())));
GroupFlagsWidget *widget = new GroupFlagsWidget(NULL,(*it).shareflags);
listWidget->setRowHeight(row, 32);
listWidget->setCellWidget(row, COLUMN_SHARE_FLAGS, widget);
listWidget->setItem(row, COLUMN_GROUPS, new QTableWidgetItem()) ;
listWidget->item(row,COLUMN_GROUPS)->setBackgroundColor(QColor(183,236,181)) ;
//connect(widget,SIGNAL(flagsChanged(FileStorageFlags)),this,SLOT(updateFlags())) ;
}
listWidget->setColumnWidth(COLUMN_SHARE_FLAGS,132) ;
//ui.incomingDir->setText(QString::fromStdString(rsFiles->getDownloadDirectory()));
listWidget->update(); /* update display */
update();
isLoading = false ;
updateGroups();
}
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();
}
void MultiInstancePanelPrivate::addTableRow(Node* node)
{
int newRowIndex = table->rowCount();
table->insertRow(newRowIndex);
std::list<boost::shared_ptr<KnobI> > instanceSpecificKnobs;
getInstanceSpecificKnobs(node, &instanceSpecificKnobs);
///first add the enabled column
{
QWidget* enabledContainer = createCheckBoxForTable(true);
table->setCellWidget(newRowIndex, 0, enabledContainer);
}
int columnIndex = 1;
for (std::list<boost::shared_ptr<KnobI> >::iterator it = instanceSpecificKnobs.begin();it!=instanceSpecificKnobs.end();++it) {
Int_Knob* isInt = dynamic_cast<Int_Knob*>(it->get());
Bool_Knob* isBool = dynamic_cast<Bool_Knob*>(it->get());
Double_Knob* isDouble = dynamic_cast<Double_Knob*>(it->get());
Color_Knob* isColor = dynamic_cast<Color_Knob*>(it->get());
String_Knob* isString = dynamic_cast<String_Knob*>(it->get());
if (!isInt || !isBool || !isDouble || !isColor || !isString) {
continue;
}
bool createCheckBox = false;
bool createSpinBox = false;
if (isBool) {
createCheckBox = true;
} else if (isInt || isDouble || isColor) {
createSpinBox = true;
}
for (int i = 0; i < (*it)->getDimension(); ++it) {
if (createCheckBox) {
assert(isBool);
bool checked = isBool->getValue();
QWidget* enabledContainer = createCheckBoxForTable(checked);
table->setCellWidget(newRowIndex, columnIndex, enabledContainer);
} else if (createSpinBox) {
double mini = INT_MIN,maxi = INT_MAX;
SpinBox::SPINBOX_TYPE type = SpinBox::DOUBLE_SPINBOX;
if (isInt) {
mini = isInt->getMinimums()[i];
maxi = isInt->getMaximums()[i];
type = SpinBox::INT_SPINBOX;
} else if (isDouble) {
mini = isDouble->getMinimums()[i];
maxi = isDouble->getMaximums()[i];
}
SpinBox* sb = new SpinBox(NULL,type);
sb->setMinimum(mini);
sb->setMaximum(maxi);
table->setCellWidget(newRowIndex, columnIndex, sb);
} else {
assert(isString);
std::string value = isString->getValue();
LineEdit* le = new LineEdit(NULL);
le->setText(value.c_str());
table->setCellWidget(newRowIndex, columnIndex, le);
}
++columnIndex;
}
}
}
void QuickStartWizard::loadShare()
{
std::cerr << "ShareManager:: In load !!!!!" << std::endl ;
std::list<SharedDirInfo>::const_iterator it;
std::list<SharedDirInfo> dirs;
rsFiles->getSharedDirectories(dirs);
ui.shareIncomingDirectory->setChecked(rsFiles->getShareDownloadDirectory());
/* get a link to the table */
QTableWidget *listWidget = ui.shareddirList;
/* remove old items ??? */
listWidget->clearContents() ;
listWidget->setRowCount(0) ;
connect(this,SIGNAL(itemClicked(QTableWidgetItem*)),this,SLOT(updateFlags(QTableWidgetItem*))) ;
int row=0 ;
for(it = dirs.begin(); it != dirs.end(); ++it,++row)
{
listWidget->insertRow(row) ;
listWidget->setItem(row,0,new QTableWidgetItem(QString::fromStdString((*it).filename)));
#ifdef USE_COMBOBOX
QComboBox *cb = new QComboBox ;
cb->addItem(tr("Network Wide")) ;
cb->addItem(tr("Browsable")) ;
cb->addItem(tr("Universal")) ;
cb->setToolTip(tr("Please decide whether this directory is\n* Network Wide: \tanonymously shared over the network (including your friends)\n* Browsable: \tbrowsable by your friends\n* Universal: \t\tboth")) ;
// TODO
// - set combobox current value depending on what rsFiles reports.
// - use a signal mapper to get the correct row that contains the combo box sending the signal:
// mapper = new SignalMapper(this) ;
//
// for(all cb)
// {
// signalMapper->setMapping(cb,...)
// }
//
int index = 0 ;
index += ((*it).shareflags & RS_FILE_HINTS_NETWORK_WIDE) > 0 ;
index += (((*it).shareflags & RS_FILE_HINTS_BROWSABLE) > 0) * 2 ;
listWidget->setCellWidget(row,1,cb);
if(index < 1 || index > 3)
std::cerr << "******* ERROR IN FILE SHARING FLAGS. Flags = " << (*it).shareflags << " ***********" << std::endl ;
else
index-- ;
cb->setCurrentIndex(index) ;
#else
QCheckBox *cb1 = new QCheckBox ;
QCheckBox *cb2 = new QCheckBox ;
cb1->setChecked( (*it).shareflags & DIR_FLAGS_NETWORK_WIDE_OTHERS ) ;
cb2->setChecked( (*it).shareflags & DIR_FLAGS_BROWSABLE_OTHERS ) ;
cb1->setToolTip(tr("If checked, the share is anonymously shared to anybody.")) ;
cb2->setToolTip(tr("If checked, the share is browsable by your friends.")) ;
listWidget->setCellWidget(row,1,cb1);
listWidget->setCellWidget(row,2,cb2);
QObject::connect(cb1,SIGNAL(toggled(bool)),this,SLOT(updateFlags(bool))) ;
QObject::connect(cb2,SIGNAL(toggled(bool)),this,SLOT(updateFlags(bool))) ;
#endif
}
//ui.incomingDir->setText(QString::fromStdString(rsFiles->getDownloadDirectory()));
listWidget->update(); /* update display */
update();
}
void CQMathMatrixWidget::slotDerivButtonPressed()
{
#ifdef _DERIV_TEST_
std::cout << "Deriv" << std::endl;
CModel* pModel = CCopasiRootContainer::getDatamodelList()->operator[](0).getModel();
CEvaluationNode* tmpnode = pModel->prepareElasticity(&pModel->getReactions()[0],
&pModel->getMetabolites()[0], false);
CEvaluationNode* tmpnode2 = pModel->prepareElasticity(&pModel->getReactions()[0],
&pModel->getMetabolites()[0], true);
//create empty environment. Variable nodes should not occur in an expression
std::vector<std::vector<std::string> > env;
std::string tmpstring = tmpnode->buildMMLString(false, env);
std::string tmpstring2 = tmpnode2->buildMMLString(false, env);
mpMML->setBaseFontPointSize(qApp->font().pointSize());
mpMML->setFontName(QtMmlWidget::NormalFont, qApp->font().family());
mpMML->setContent(tmpstring.c_str());
mpMML2->setBaseFontPointSize(qApp->font().pointSize());
mpMML2->setFontName(QtMmlWidget::NormalFont, qApp->font().family());
mpMML2->setContent(tmpstring2.c_str());
QTableWidget * pTable = new QTableWidget(pModel->getReactions().size(), pModel->getMetabolites().size());
pTable->show();
int i, imax = pModel->getMetabolites().size();
int j, jmax = pModel->getReactions().size();
for (i = 0; i < imax; ++i)
for (j = 0; j < jmax; ++j)
{
//CEvaluationNode* tmpnode = pModel->prepareElasticity(pModel->getReactions()[j],
// pModel->getMetabolites()[i], false);
CEvaluationNode* tmpnode2 = pModel->prepareElasticity(&pModel->getReactions()[j],
&pModel->getMetabolites()[i], true);
//evaluate
CExpression * tmpExp = new CExpression("tmp expr", pModel);
tmpExp->setRoot(tmpnode2);
tmpExp->compile();
std::cout << tmpExp->calcValue() << std::endl;
//create empty environment. Variable nodes should not occur in an expression
std::vector<std::vector<std::string> > env;
//std::string tmpstring = tmpnode->buildMMLString(false, env);
std::string tmpstring2 = tmpnode2->buildMMLString(false, env);
QtMmlWidget* tmpmml = new QtMmlWidget();
tmpmml->setBaseFontPointSize(qApp->font().pointSize() - 2);
tmpmml->setFontName(QtMmlWidget::NormalFont, qApp->font().family());
tmpmml->setContent(tmpstring2.c_str());
pTable->setCellWidget(j, i, tmpmml);
//tmpmml = new QtMmlWidget();
//tmpmml->setBaseFontPointSize(qApp->font().pointSize()-2);
//tmpmml->setFontName(QtMmlWidget::NormalFont, qApp->font().family());
//tmpmml->setContent(tmpstring.c_str());
//pTable->setCellWidget(i, 1, tmpmml);
}
pTable->resizeColumnsToContents();
pTable->resizeRowsToContents();
#endif
}
void AddEditBlog::fetchedBlogId(const QList< QMap < QString, QString > > &list)
{
if (d->mFetchBlogIdTimer) {
d->mFetchBlogIdTimer->deleteLater();
d->mFetchBlogIdTimer = Q_NULLPTR;
}
hideWaitWidget();
QString blogId, blogName, blogUrl, apiUrl;
const int listCount(list.count());
if (listCount > 1) {
qCDebug(BLOGILO_LOG) << "User has more than ONE blog!";
QDialog *blogsDialog = new QDialog(this);
QTableWidget *blogsList = new QTableWidget(blogsDialog);
blogsList->setSelectionBehavior(QAbstractItemView::SelectRows);
QList< QMap<QString, QString> >::const_iterator it = list.constBegin();
QList< QMap<QString, QString> >::const_iterator endIt = list.constEnd();
int i = 0;
blogsList->setColumnCount(4);
QStringList headers;
headers << i18n("Title") << i18n("URL");
blogsList->setHorizontalHeaderLabels(headers);
blogsList->setColumnHidden(2, true);
blogsList->setColumnHidden(3, true);
for (; it != endIt; ++it) {
qCDebug(BLOGILO_LOG) << it->value(QStringLiteral("title"));
blogsList->insertRow(i);
blogsList->setCellWidget(i, 0, new QLabel(it->value(QStringLiteral("title"))));
blogsList->setCellWidget(i, 1, new QLabel(it->value(QStringLiteral("url"))));
blogsList->setCellWidget(i, 2, new QLabel(it->value(QStringLiteral("id"))));
blogsList->setCellWidget(i, 3, new QLabel(it->value(QStringLiteral("apiUrl"))));
++i;
}
QVBoxLayout *mainLayout = new QVBoxLayout;
blogsDialog->setLayout(mainLayout);
mainLayout->addWidget(blogsList);
blogsDialog->setWindowTitle(i18n("Which blog?"));
if (blogsDialog->exec()) {
int row = blogsList->currentRow();
if (row == -1) {
delete blogsDialog;
return;
}
blogId = qobject_cast<QLabel *>(blogsList->cellWidget(row, 2))->text();
blogName = qobject_cast<QLabel *>(blogsList->cellWidget(row, 0))->text();
blogUrl = qobject_cast<QLabel *>(blogsList->cellWidget(row, 1))->text();
apiUrl = qobject_cast<QLabel *>(blogsList->cellWidget(row, 3))->text();
} else {
delete blogsDialog;
return;
}
delete blogsDialog;
} else if (listCount > 0) {
blogId = list.constBegin()->value(QStringLiteral("id"));
blogName = list.constBegin()->value(QStringLiteral("title"));
blogUrl = list.constBegin()->value(QStringLiteral("url"));
apiUrl = list.constBegin()->value(QStringLiteral("apiUrl"));
} else {
KMessageBox::sorry(this, i18n("Sorry, No blog found with the specified account info."));
return;
}
d->ui.txtId->setText(blogId);
d->ui.txtTitle->setText(blogName);
d->ui.txtId->setEnabled(true);
d->ui.btnFetch->setEnabled(true);
d->ui.btnAutoConf->setEnabled(true);
if (!apiUrl.isEmpty()) {
d->ui.txtUrl->setText(apiUrl);
} else {
apiUrl = d->ui.txtUrl->text();
}
if (!blogUrl.isEmpty()) {
d->bBlog->setBlogUrl(blogUrl);
} else {
if (d->tmpBlogUrl.isEmpty()) {
d->bBlog->setBlogUrl(apiUrl);
} else {
d->bBlog->setBlogUrl(d->tmpBlogUrl);
}
}
d->bBlog->setUrl(QUrl(apiUrl));
d->bBlog->setUsername(d->ui.txtUser->text());
d->bBlog->setPassword(d->ui.txtPass->text());
d->bBlog->setBlogId(blogId);
d->bBlog->setTitle(blogName);
}
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 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);
}
}