void AbstractCameraManager::setProperties(std::vector<CameraProperty> &properties) {
cameraProperties = std::vector<CameraProperty>(properties);
for(unsigned int i=0; i<cameraProperties.size(); i++) {
CameraProperty &property = cameraProperties.at(i);
//qDebug() << property.getName().c_str() << reinterpret_cast<quintptr>(&property);
QTreeWidgetItem* it = new QTreeWidgetItem();
it->setText( Ui::PropertyName, property.getName().c_str());
propertiesList.addTopLevelItem(it);
//checkbox
QCheckBox* box = new QCheckBox();
box->setProperty("CameraProperty", QVariant::fromValue(reinterpret_cast<quintptr>(&property)) );
if(!property.getCanAuto()) box->setEnabled(false);
propertiesList.setItemWidget(it, Ui::PropertyAuto, box);
connect( box, SIGNAL(stateChanged(int)), this, SLOT(on_propertyCheckbox_changed(int)) );
//slider
if( property.getType() == CameraManager::AUTOTRIGGER ) continue;
QSlider* slider = new QSlider(Qt::Horizontal);
slider->setProperty("CameraProperty", QVariant::fromValue(reinterpret_cast<quintptr>(&property)) );
slider->setProperty("TreeWidgetItem", QVariant::fromValue(reinterpret_cast<quintptr>(it)) );
slider->setTracking(true); //might be wanted
slider->setRange(property.getMinToSlider(), property.getMaxToSLider());
propertiesList.setItemWidget(it, Ui::PropertySlider, slider);
box->setProperty("TreeWidgetSlider", QVariant::fromValue(reinterpret_cast<quintptr>(slider)) );
connect( slider, SIGNAL(valueChanged(int)), this, SLOT(on_propertySlider_changed(int)) );
}
propertiesList.resizeColumnToContents(0);
propertiesList.resizeColumnToContents(1);
propertiesList.resizeColumnToContents(2);
}
QList<QWidget*> createItemWidgets(const QModelIndex& /*index*/) const
{
// a lump of coal and a piece of elastic will get you through the world
QModelIndex idx = property("goya:creatingWidgetForIndex").value<QModelIndex>();
QWidget *page = new QWidget;
QHBoxLayout *layout = new QHBoxLayout(page);
QCheckBox *checkBox = new QCheckBox;
checkBox->setProperty("fileitem", idx.data());
connect(checkBox, SIGNAL(toggled(bool)), m_parent, SLOT(toggleFileItem(bool)));
QLabel *thumbnail = new QLabel;
QLabel *filename = new QLabel;
QLabel *dateModified = new QLabel;
layout->addWidget(checkBox);
layout->addWidget(thumbnail);
layout->addWidget(filename);
layout->addWidget(dateModified);
page->setFixedSize(600, 200);
return QList<QWidget*>() << page;
}
QWidget* PrefsDialog::createCurvyForm(ViewInfoThing * viewInfoThing)
{
QGroupBox * groupBox = new QGroupBox(tr("Curvy vs. straight wires"));
QVBoxLayout *layout = new QVBoxLayout;
QLabel * label1 = new QLabel(tr("When you mouse-down and drag on a wire or the leg of a part (as opposed to a connector or a bendpoint) "
"do you want to change the curvature of the wire (or leg) or drag out a new bendpoint?"));
label1->setWordWrap(true);
layout->addWidget(label1);
QLabel * label2 = new QLabel(tr("This checkbox sets the default behavior. "
"You can switch back to the non-default behavior by holding down the Control key (Mac: Command key) when you drag."));
label2->setWordWrap(true);
layout->addWidget(label2);
layout->addSpacing(10);
QCheckBox * checkbox = new QCheckBox("Curvy wires and legs");
checkbox->setProperty("index", viewInfoThing->index);
checkbox->setChecked(viewInfoThing->curvy);
connect(checkbox, SIGNAL(clicked()), this, SLOT(curvyChanged()));
layout->addWidget(checkbox);
groupBox->setLayout(layout);
return groupBox;
}
void CComputerConfViewPrivate::appendShop()
{
int iCol = m_ptrGridLayout->columnCount();
//
QHBoxLayout * ptrHLayout = new QHBoxLayout;
QCheckBox * ptrCheckBox = new QCheckBox;
ptrCheckBox->setChecked(true);
ptrCheckBox->setProperty("column",iCol-ciHeaderColCount);
//connect(ptrCheckBox,SIGNAL(stateChanged(int)), this, SLOT(onShopActivation(int)));
ptrHLayout->addWidget(ptrCheckBox);
QPushButton * ptrRemShop = new QPushButton;
ptrRemShop->setIcon(QIcon(":/images/minus.png"));
ptrRemShop->setFlat(true);
ptrRemShop->setProperty("column",iCol-ciHeaderColCount);
//connect(ptrRemShop,SIGNAL(clicked ( bool )), this, SLOT(onCompRowRemove()));
ptrHLayout->addWidget(ptrRemShop);
m_ptrGridLayout->addLayout(ptrHLayout,0,iCol,Qt::AlignCenter);
//
QComboBox * ptrComboBox = new QComboBox;
ptrRemShop->setProperty("column",iCol-ciHeaderColCount);
m_ptrGridLayout->addWidget(ptrComboBox,1,iCol);
}
void ItemHandlerCheckbox::Handle (const QDomElement& item,
QWidget *pwidget)
{
QGridLayout *lay = qobject_cast<QGridLayout*> (pwidget->layout ());
QCheckBox *box = new QCheckBox (XSD_->GetLabel (item));
XSD_->SetTooltip (box, item);
box->setObjectName (item.attribute ("property"));
const QVariant& value = XSD_->GetValue (item);
box->setCheckState (value.toBool () ? Qt::Checked : Qt::Unchecked);
connect (box,
SIGNAL (stateChanged (int)),
this,
SLOT (updatePreferences ()));
box->setProperty ("ItemHandler", QVariant::fromValue<QObject*> (this));
box->setProperty ("SearchTerms", QStringList (box->text ()));
lay->addWidget (box, lay->rowCount (), 0, 1, 2, Qt::AlignTop);
}
void
ChooseProvidersPage::setFields( const QList<qint64> &fields, qint64 checkedFields )
{
QLayout *fieldsLayout = fieldsBox->layout();
foreach( qint64 field, fields )
{
QString name = Meta::i18nForField( field );
QCheckBox *checkBox = new QCheckBox( name );
fieldsLayout->addWidget( checkBox );
checkBox->setCheckState( ( field & checkedFields ) ? Qt::Checked : Qt::Unchecked );
checkBox->setProperty( "field", field );
connect( checkBox, SIGNAL(stateChanged(int)), SIGNAL(checkedFieldsChanged()) );
}
QWidget* CameraParamsWidget::createEditorFor(const calibration::CameraParam& param)
{
if(!param.choices.empty())
{
QComboBox* box = new QComboBox(m_w);
for(uint i = 0; i < param.choices.size(); ++i)
{
box->addItem(
param.choices[i].label.c_str(),
param.choices[i].value
);
if(param.choices[i].value == param.value)
box->setCurrentIndex(i);
}
box->setProperty("paramID", param.id);
connect(box, SIGNAL(activated(int)), SLOT(updateComboBox()));
return box;
}
if(param.minimum == 0 && param.maximum == 1)
{
QCheckBox* box = new QCheckBox(m_w);
box->setChecked(param.value);
box->setProperty("paramID", param.id);
connect(box, SIGNAL(clicked(bool)), SLOT(updateCheckBox(bool)));
return box;
}
QSlider* slider = new QSlider(Qt::Horizontal, m_w);
slider->setMinimum(param.minimum);
slider->setMaximum(param.maximum);
slider->setValue(param.value);
slider->setProperty("paramID", param.id);
connect(slider, SIGNAL(valueChanged(int)), SLOT(updateSlider(int)));
return slider;
}
void CComputerConfViewPrivate::appendRow()
{
//usun ostatni element rozpychajacy
int iRow = m_ptrGridLayout->rowCount();
for(int iCol = 0;iCol<m_ptrGridLayout->columnCount();++iCol)
{
//QLayoutItem * ptrItem = m_ptrGridLayout->itemAtPosition(iRow,iCol);
}
//////////////////////////////////////////////////////////////////////////
QPushButton * ptrRemRow = new QPushButton;
ptrRemRow->setIcon(QIcon(":/images/minus.png"));
ptrRemRow->setFlat(true);
ptrRemRow->setProperty("row",iRow-ciHeaderRowCount);
connect(ptrRemRow,SIGNAL(clicked ( bool )), this, SLOT(onCompRowRemove()));
m_ptrGridLayout->addWidget(ptrRemRow,iRow,RowInd_Remove,Qt::AlignCenter);
//////////////////////////////////////////////////////////////////////////
QCheckBox * ptrCheckBox = new QCheckBox;
ptrCheckBox->setChecked(true);
ptrCheckBox->setProperty("row",iRow-ciHeaderRowCount);
connect(ptrCheckBox,SIGNAL(stateChanged(int)), this, SLOT(onRowActivation(int)));
m_ptrGridLayout->addWidget(ptrCheckBox,iRow,RowInd_Active,Qt::AlignCenter);
//////////////////////////////////////////////////////////////////////////
//QLabel * ptrCompName = new QLabel;
QLineEdit * ptrCompName = new QLineEdit;
ptrCompName->setProperty("row",iRow-ciHeaderRowCount);
connect(ptrCompName,SIGNAL(editingFinished ()), this, SLOT(onCompNameEditFinished()));
m_ptrGridLayout->addWidget(ptrCompName,iRow,RowInd_CompName);
//////////////////////////////////////////////////////////////////////////
//QLabel * ptrCompCode = new QLabel;
QLineEdit * ptrCompCode = new QLineEdit;
ptrCompCode->setProperty("row",iRow-ciHeaderRowCount);
connect(ptrCompCode,SIGNAL(editingFinished ()), this, SLOT(onCompCodeEditFinished()));
m_ptrGridLayout->addWidget(ptrCompCode,iRow,RowInd_CompCode);
//////////////////////////////////////////////////////////////////////////
QLabel * ptrBestPrice = new QLabel;
m_ptrGridLayout->addWidget(ptrBestPrice,iRow,RowInd_BestPrice);
//////////////////////////////////////////////////////////////////////////
for(int iCol = 0;iCol<m_ptrGridLayout->columnCount();++iCol)
{
QSpacerItem * ptrItem = new QSpacerItem(0,0,QSizePolicy::Expanding,QSizePolicy::Expanding);
m_ptrGridLayout->addItem(ptrItem,iRow+1,iCol);
}
}
void CheatDialog::LoadCheats() {
cheats = Core::System::GetInstance().CheatEngine().GetCheats();
ui->tableCheats->setRowCount(cheats.size());
for (size_t i = 0; i < cheats.size(); i++) {
QCheckBox* enabled = new QCheckBox();
enabled->setChecked(cheats[i]->IsEnabled());
enabled->setStyleSheet("margin-left:7px;");
ui->tableCheats->setItem(i, 0, new QTableWidgetItem());
ui->tableCheats->setCellWidget(i, 0, enabled);
ui->tableCheats->setItem(
i, 1, new QTableWidgetItem(QString::fromStdString(cheats[i]->GetName())));
ui->tableCheats->setItem(
i, 2, new QTableWidgetItem(QString::fromStdString(cheats[i]->GetType())));
enabled->setProperty("row", static_cast<int>(i));
connect(enabled, &QCheckBox::stateChanged, this, &CheatDialog::OnCheckChanged);
}
}
void MultipleAnswers::render(QWidget *widget)
{
MultipleAnswersQuestion const* qq = question();
QButtonGroup *answerButtons = new QButtonGroup(widget);
answerButtons->setExclusive(false);
QLayout *layout = widget->layout();
debug() << "Rendering a MultipleAnswers question: " << qq->id();
for (auto answer : qq->answers()) {
QCheckBox *answerRadio = new QCheckBox(QString::fromStdString(answer->text()), widget);
answerRadio->setProperty("answerId", answer->id());
answerRadio->setChecked(qq->isChosen(answer));
layout->addWidget(answerRadio);
answerButtons->addButton(answerRadio);
}
QObject::connect(answerButtons, SIGNAL(buttonReleased(QAbstractButton*)),
this, SLOT(toggleAnswerSelection(QAbstractButton*)));
}
void MainWindow::addLevelCheckBox(QWidget * iParent, int iLevel, QString iLabel)
{
int nboxes = (int)m_levelCheckBoxes.size();
QCheckBox * checkBox = new QCheckBox(iParent);
//checkBox->setChecked(Qt::Checked);
checkBox->setChecked(Qt::Unchecked);
checkBox->setGeometry(QRect(10, 10 + nboxes*30, 80, 20));
if (!iLabel.isEmpty())
{
checkBox->setText(iLabel);
}
else
{
checkBox->setText("level" + QString::number(iLevel));
}
//checkBox->setProperty("idx", iLevel);
checkBox->setProperty("idx", nboxes);
checkBox->setChecked(true);
checkBox->show();
m_levelCheckBoxes.push_back(checkBox);
connect(checkBox, SIGNAL(clicked()), this, SLOT(levelCheckBoxModified()));
}
Channels::Channels(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, FirmwareInterface * firmware):
ModelPanel(parent, model, generalSettings, firmware)
{
QGridLayout * gridLayout = new QGridLayout(this);
bool minimize = false;
int col = 1;
if (firmware->getCapability(ChannelsName)) {
minimize=true;
addLabel(gridLayout, tr("Name"), col++);
}
addLabel(gridLayout, tr("Subtrim"), col++, minimize);
addLabel(gridLayout, tr("Min"), col++, minimize);
addLabel(gridLayout, tr("Max"), col++, minimize);
addLabel(gridLayout, tr("Direction"), col++, minimize);
if (IS_TARANIS(GetEepromInterface()->getBoard()))
addLabel(gridLayout, tr("Curve"), col++, minimize);
if (firmware->getCapability(PPMCenter))
addLabel(gridLayout, tr("PPM Center"), col++, minimize);
if (firmware->getCapability(SYMLimits))
addLabel(gridLayout, tr("Linear Subtrim"), col++, true);
for (int i=0; i<firmware->getCapability(Outputs); i++) {
col = 0;
// Channel label
QLabel *label = new QLabel(this);
label->setText(tr("Channel %1").arg(i+1));
label->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
gridLayout->addWidget(label, i+1, col++, 1, 1);
// Channel name
int nameLen = firmware->getCapability(ChannelsName);
if (nameLen > 0) {
QLineEdit * name = new QLineEdit(this);
name->setProperty("index", i);
name->setMaxLength(nameLen);
QRegExp rx(CHAR_FOR_NAMES_REGEX);
name->setValidator(new QRegExpValidator(rx, this));
name->setText(model.limitData[i].name);
connect(name, SIGNAL(editingFinished()), this, SLOT(nameEdited()));
gridLayout->addWidget(name, i+1, col++, 1, 1);
}
// Channel offset
limitsGroups << new LimitsGroup(firmware, gridLayout, i+1, col++, model.limitData[i].offset, -1000, 1000, 0);
// Channel min
limitsGroups << new LimitsGroup(firmware, gridLayout, i+1, col++, model.limitData[i].min, -model.getChannelsMax()*10, 0, -1000);
// Channel max
limitsGroups << new LimitsGroup(firmware, gridLayout, i+1, col++, model.limitData[i].max, 0, model.getChannelsMax()*10, 1000);
// Channel inversion
QComboBox * invCB = new QComboBox(this);
invCB->insertItems(0, QStringList() << tr("---") << tr("INV"));
invCB->setProperty("index", i);
invCB->setCurrentIndex((model.limitData[i].revert) ? 1 : 0);
connect(invCB, SIGNAL(currentIndexChanged(int)), this, SLOT(invEdited()));
gridLayout->addWidget(invCB, i+1, col++, 1, 1);
// Curve
if (IS_TARANIS(GetEepromInterface()->getBoard())) {
QComboBox * curveCB = new QComboBox(this);
curveCB->setProperty("index", i);
int numcurves = firmware->getCapability(NumCurves);
for (int j=-numcurves; j<=numcurves; j++) {
curveCB->addItem(CurveReference(CurveReference::CURVE_REF_CUSTOM, j).toString(), j);
}
curveCB->setCurrentIndex(model.limitData[i].curve.value+numcurves);
connect(curveCB, SIGNAL(currentIndexChanged(int)), this, SLOT(curveEdited()));
gridLayout->addWidget(curveCB, i+1, col++, 1, 1);
}
// PPM center
if (firmware->getCapability(PPMCenter)) {
QSpinBox * center = new QSpinBox(this);
center->setProperty("index", i);
center->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
center->setSuffix("us");
center->setMinimum(1375);
center->setMaximum(1625);
center->setValue(1500);
center->setValue(model.limitData[i].ppmCenter + 1500);
connect(center, SIGNAL(editingFinished()), this, SLOT(ppmcenterEdited()));
gridLayout->addWidget(center, i+1, col++, 1, 1);
}
// Symetrical limits
if (firmware->getCapability(SYMLimits)) {
QCheckBox * symlimits = new QCheckBox(this);
symlimits->setProperty("index", i);
symlimits->setChecked(model.limitData[i].symetrical);
connect(symlimits, SIGNAL(toggled(bool)), this, SLOT(symlimitsEdited()));
gridLayout->addWidget(symlimits, i+1, col++, 1, 1);
}
}
void VPiano::initExtraControllers()
{
QWidget *w = NULL;
QCheckBox *chkbox = NULL;
Knob *knob = NULL;
QSpinBox *spin = NULL;
QSlider *slider = NULL;
QToolButton *button = NULL;
foreach(const QString& s, m_extraControls) {
QString lbl;
int control = 0;
int type = 0;
int minValue = 0;
int maxValue = 127;
int defValue = 0;
int value = 0;
int size = 100;
QString fileName;
ExtraControl::decodeString( s, lbl, control, type,
minValue, maxValue, defValue,
size, fileName );
if (m_ctlState[m_channel].contains(control))
value = m_ctlState[m_channel][control];
else
value = defValue;
switch(type) {
case 0:
chkbox = new QCheckBox(this);
if (dlgPreferences()->getStyledWidgets()) {
chkbox->setStyle(m_dialStyle);
}
chkbox->setProperty(MIDICTLONVALUE, maxValue);
chkbox->setProperty(MIDICTLOFFVALUE, minValue);
chkbox->setChecked(bool(value));
connect(chkbox, SIGNAL(clicked(bool)), SLOT(slotControlClicked(bool)));
w = chkbox;
break;
case 1:
knob = new Knob(this);
knob->setFixedSize(32, 32);
knob->setStyle(dlgPreferences()->getStyledWidgets()? m_dialStyle : NULL);
knob->setMinimum(minValue);
knob->setMaximum(maxValue);
knob->setValue(value);
knob->setToolTip(QString::number(value));
knob->setDefaultValue(defValue);
knob->setDialMode(Knob::LinearMode);
connect(knob, SIGNAL(sliderMoved(int)), SLOT(slotExtraController(int)));
w = knob;
break;
case 2:
spin = new QSpinBox(this);
spin->setMinimum(minValue);
spin->setMaximum(maxValue);
spin->setValue(value);
connect(spin, SIGNAL(valueChanged(int)), SLOT(slotExtraController(int)));
w = spin;
break;
case 3:
slider = new QSlider(this);
slider->setOrientation(Qt::Horizontal);
slider->setFixedWidth(size);
slider->setMinimum(minValue);
slider->setMaximum(maxValue);
slider->setToolTip(QString::number(value));
slider->setValue(value);
connect(slider, SIGNAL(sliderMoved(int)), SLOT(slotExtraController(int)));
w = slider;
break;
case 4:
button = new QToolButton(this);
button->setText(lbl);
button->setProperty(MIDICTLONVALUE, maxValue);
button->setProperty(MIDICTLOFFVALUE, minValue);
connect(button, SIGNAL(clicked(bool)), SLOT(slotControlClicked(bool)));
w = button;
break;
case 5:
control = 255;
button = new QToolButton(this);
button->setText(lbl);
button->setProperty(SYSEXFILENAME, fileName);
button->setProperty(SYSEXFILEDATA, readSysexDataFile(fileName));
connect(button, SIGNAL(clicked(bool)), SLOT(slotControlClicked(bool)));
w = button;
break;
default:
w = NULL;
}
if (w != NULL) {
if (!lbl.isEmpty() && type < 4) {
QLabel *qlbl = new QLabel(lbl, this);
qlbl->setMargin(TOOLBARLABELMARGIN);
ui.toolBarExtra->addWidget(qlbl);
//connect(qlbl, SIGNAL(destroyed(QObject*)), SLOT(slotDebugDestroyed(QObject*)));
}
w->setProperty(MIDICTLNUMBER, control);
w->setFocusPolicy(Qt::NoFocus);
ui.toolBarExtra->addWidget(w);
//connect(w, SIGNAL(destroyed(QObject*)), SLOT(slotDebugDestroyed(QObject*)));
}
}
HistoryWidget::HistoryWidget(QWidget *parent)
: QDialog(parent)
{
setObjectName("HistoryWidget");
setWindowTitle(tr("History Data View"));
// layout - top
QHBoxLayout *horiLayoutTop = new QHBoxLayout();
QPushButton *buttonQuit = new QPushButton(this);
buttonQuit->setObjectName("buttonQuit");
horiLayoutTop->addSpacing(25);
horiLayoutTop->addWidget(buttonQuit, 0, Qt::AlignLeft);
horiLayoutTop->addStretch();
// button-export
QPushButton *buttonExport = new QPushButton(this);
buttonExport->setObjectName("buttonExport");
horiLayoutTop->addWidget(buttonExport);
horiLayoutTop->addStretch();
// button-open
QPushButton *buttonOpen = new QPushButton(this);
buttonOpen->setObjectName("buttonOpen");
horiLayoutTop->addWidget(buttonOpen);
horiLayoutTop->addStretch();
QFormLayout *formLayoutTime = new QFormLayout();
formLayoutTime->setFormAlignment(Qt::AlignVCenter);
horiLayoutTop->addLayout(formLayoutTime);
horiLayoutTop->addStretch();
QDateTimeEdit *dateTimeEditStart = new QDateTimeEdit(this);
dateTimeEditStart->setObjectName("dateTimeEditStart");
dateTimeEditStart->setDisplayFormat("yyyy-MM-dd HH:mm:ss");
formLayoutTime->addRow(tr("Start Time:"), dateTimeEditStart);
QDateTimeEdit *dateTimeEditEnd = new QDateTimeEdit(this);
dateTimeEditEnd->setObjectName("dateTimeEditEnd");
dateTimeEditEnd->setDisplayFormat("yyyy-MM-dd HH:mm:ss");
formLayoutTime->addRow(tr("End Time:"), dateTimeEditEnd);
//LBP
QFormLayout *formLayoutLBP = new QFormLayout();
formLayoutLBP->setFormAlignment(Qt::AlignVCenter);
formLayoutLBP->setLabelAlignment(Qt::AlignRight);
horiLayoutTop->addLayout(formLayoutLBP);
horiLayoutTop->addStretch();
QCheckBox *checkBoxLBPMajor = new QCheckBox(tr("Major"), this);
checkBoxLBPMajor->setProperty("curveColor", "#101010");
QCheckBox *checkBoxLBPMinor = new QCheckBox(tr("Minor"), this);
checkBoxLBPMinor->setProperty("curveColor", "#101010");
formLayoutLBP->addRow(tr("LBP:"), checkBoxLBPMajor);
formLayoutLBP->addRow("", checkBoxLBPMinor);
//RBP
QFormLayout *formLayoutRBP = new QFormLayout();
formLayoutRBP->setFormAlignment(Qt::AlignVCenter);
formLayoutRBP->setLabelAlignment(Qt::AlignRight);
horiLayoutTop->addLayout(formLayoutRBP);
horiLayoutTop->addStretch();
QCheckBox *checkBoxRBPMajor = new QCheckBox(tr("Major"), this);
checkBoxRBPMajor->setProperty("curveColor", "#101010");
QCheckBox *checkBoxRBPMinor = new QCheckBox(tr("Minor"), this);
checkBoxRBPMinor->setProperty("curveColor", "#101010");
formLayoutRBP->addRow(tr("RBP:"), checkBoxRBPMajor);
formLayoutRBP->addRow("", checkBoxRBPMinor);
//LRP
QFormLayout *formLayoutLRP = new QFormLayout();
formLayoutLRP->setFormAlignment(Qt::AlignVCenter);
formLayoutLRP->setLabelAlignment(Qt::AlignRight);
horiLayoutTop->addLayout(formLayoutLRP);
horiLayoutTop->addStretch();
QCheckBox *checkBoxLRPTheory = new QCheckBox(tr("Theory"), this);
checkBoxLRPTheory->setProperty("curveColor", "#101010");
QCheckBox *checkBoxLRPReal = new QCheckBox(tr("Real"), this);
checkBoxLRPReal->setProperty("curveColor", "#101010");
formLayoutLRP->addRow(tr("LRP:"), checkBoxLRPTheory);
formLayoutLRP->addRow("", checkBoxLRPReal);
//RRP
QFormLayout *formLayoutRRP = new QFormLayout();
formLayoutRRP->setFormAlignment(Qt::AlignVCenter);
formLayoutRRP->setLabelAlignment(Qt::AlignRight);
horiLayoutTop->addLayout(formLayoutRRP);
horiLayoutTop->addStretch();
QCheckBox *checkBoxRRPTheory = new QCheckBox(tr("Theory"), this);
checkBoxRRPTheory->setProperty("curveColor", "#101010");
QCheckBox *checkBoxRRPReal = new QCheckBox(tr("Real"), this);
checkBoxRRPReal->setProperty("curveColor", "#101010");
formLayoutRRP->addRow(tr("RRP:"), checkBoxRRPTheory);
formLayoutRRP->addRow("", checkBoxRRPReal);
// button-update
QPushButton *buttonUpdate = new QPushButton(this);
buttonUpdate->setObjectName("buttonUpdate");
horiLayoutTop->addWidget(buttonUpdate);
horiLayoutTop->addStretch();
/*
// button-undo
QPushButton *buttonUndo = new QPushButton(this);
buttonUndo->setObjectName("buttonUndo");
horiLayoutTop->addWidget(buttonUndo);
horiLayoutTop->addStretch();
*/
// middle - curves
CurveWidget* curveHistory = new CurveWidget(tr("History Data View"), this, true);
curveHistory->setMaximumWidth(10000000);
curveHistory->setScaleLabelFormat("yyyy/MM/dd\n HH:mm:ss");
curveHistory->clear();
QVBoxLayout *vertLayoutMain = new QVBoxLayout(this);
vertLayoutMain->addLayout(horiLayoutTop);
vertLayoutMain->addWidget(curveHistory);
connect(buttonQuit, &QPushButton::clicked, this, [=](){
this->accept();
});
connect(buttonOpen, &QPushButton::clicked, this, [=](){
QFileDialog fileDialog(this,
tr("Open history database files"),
QApplication::applicationDirPath().append("/../data"),
tr("Data Base File (*.db *.mdb)"));
if (fileDialog.exec() == QDialog::Rejected) {
return;
}
// clear curve
curveHistory->clear();
//
QStringList filePaths = fileDialog.selectedFiles();
if (filePaths.isEmpty()) {
return;
}
QString filePath = filePaths.first();
if (filePath.isEmpty()) {
return;
}
// open database
if (!DataBaseMgr::instance().open(filePath)) {
Q_ASSERT(false);
return;
}
//
QDateTime startTime = QDateTime::fromMSecsSinceEpoch(DataBaseMgr::instance().startTime());
QDateTime endTime = QDateTime::fromMSecsSinceEpoch(DataBaseMgr::instance().endTime());
dateTimeEditStart->setDateTimeRange(startTime, endTime);
dateTimeEditEnd->setDateTimeRange(startTime, endTime);
dateTimeEditEnd->setDateTime(endTime);
dateTimeEditStart->setDateTime(startTime);
// curve title
curveHistory->setTitle(tr("History Data View")
.append(" (")
.append(QFileInfo(filePath).fileName())
.append(")"));
});
connect(buttonExport, &QPushButton::clicked, this, [=](){
QStringList filePaths = QFileDialog::getOpenFileNames(this,
tr("Convert data base files to txt format and save..."),
QApplication::applicationDirPath().append("/../data"),
tr("Data Base File (*.db *.mdb)"));
if (filePaths.isEmpty()) {
return;
}
//
if (DataBaseMgr::instance().convertToText(filePaths)) {
QMessageBox::information(this, tr("Convert Database file"), tr("Convert successfully!"));
} else {
QMessageBox::information(this, tr("Convert Database file"), tr("Convert failed!"));
}
});
connect(dateTimeEditStart, &QDateTimeEdit::dateTimeChanged, this, [=](const QDateTime &dateTime){
QDateTime endDateTime = dateTimeEditEnd->dateTime();
if (dateTime > endDateTime) {
dateTimeEditStart->setDateTime(endDateTime);
}
});
connect(dateTimeEditEnd, &QDateTimeEdit::dateTimeChanged, this, [=](const QDateTime &dateTime){
QDateTime startDateTime = dateTimeEditStart->dateTime();
if (dateTime < startDateTime) {
dateTimeEditEnd->setDateTime(startDateTime);
}
});
connect(checkBoxLBPMajor, &QCheckBox::toggled, this, [=](bool checked){
_v_curve_checked[0] = checked;
});
connect(checkBoxLBPMinor, &QCheckBox::toggled, this, [=](bool checked){
_v_curve_checked[1] = checked;
});
connect(checkBoxRBPMajor, &QCheckBox::toggled, this, [=](bool checked){
_v_curve_checked[2] = checked;
});
connect(checkBoxRBPMinor, &QCheckBox::toggled, this, [=](bool checked){
_v_curve_checked[3] = checked;
});
connect(checkBoxLRPTheory, &QCheckBox::toggled, this, [=](bool checked){
_v_curve_checked[4] = checked;
});
connect(checkBoxLRPReal, &QCheckBox::toggled, this, [=](bool checked){
_v_curve_checked[5] = checked;
});
connect(checkBoxRRPTheory, &QCheckBox::toggled, this, [=](bool checked){
_v_curve_checked[6] = checked;
});
connect(checkBoxRRPReal, &QCheckBox::toggled, this, [=](bool checked){
_v_curve_checked[7] = checked;
});
connect(buttonUpdate, &QPushButton::clicked, this, [=](){
// clear curve
curveHistory->clear();
QVector<QPointF> points;
quint64 startTime = dateTimeEditStart->dateTime().toMSecsSinceEpoch();
quint64 endTime = dateTimeEditEnd->dateTime().toMSecsSinceEpoch();
// LBP-Major
if (checkBoxLBPMajor->isChecked()) {
// read
points.clear();
if (DataBaseMgr::instance().read("lMBrakeP", points, startTime, endTime)) {
curveHistory->addCurve(tr("LBP-Major"), QPen(randomColor(0)), points);
}
}
//QApplication::processEvents();
// LBP-Minor
if (checkBoxLBPMinor->isChecked()) {
// read
points.clear();
if (DataBaseMgr::instance().read("lABrakeP", points, startTime, endTime)) {
curveHistory->addCurve(tr("LBP-Minor"), QPen(randomColor(1)), points);
}
}
//QApplication::processEvents();
// RBP-Major
if (checkBoxRBPMajor->isChecked()) {
// read
points.clear();
if (DataBaseMgr::instance().read("rMBrakeP", points, startTime, endTime)) {
curveHistory->addCurve(tr("RBP-Major"), QPen(randomColor(2)), points);
}
}
//QApplication::processEvents();
// RBP-Minor
if (checkBoxRBPMinor->isChecked()) {
// read
points.clear();
if (DataBaseMgr::instance().read("rABrakeP", points, startTime, endTime)) {
curveHistory->addCurve(tr("RBP-Minor"), QPen(randomColor(3)), points);
}
}
//QApplication::processEvents();
// LRP-Theory
if (checkBoxLRPTheory->isChecked()) {
// read
points.clear();
if (DataBaseMgr::instance().read("lTheorySpd", points, startTime, endTime)) {
curveHistory->addCurve(tr("LRP-Theory"), QPen(randomColor(4)), points);
}
}
//QApplication::processEvents();
// LRP-Real
if (checkBoxLRPReal->isChecked()) {
// read
points.clear();
if (DataBaseMgr::instance().read("lWheelSpd", points, startTime, endTime)) {
curveHistory->addCurve(tr("LRP-Real"), QPen(randomColor(5)), points);
}
}
//QApplication::processEvents();
// RRP-Theory
if (checkBoxRRPTheory->isChecked()) {
// read
points.clear();
if (DataBaseMgr::instance().read("rTheorySpd", points, startTime, endTime)) {
curveHistory->addCurve(tr("RRP-Theory"), QPen(randomColor(6)), points);
}
}
//QApplication::processEvents();
// RRP-Real
if (checkBoxRRPReal->isChecked()) {
// read
points.clear();
if (DataBaseMgr::instance().read("rWheelSpd", points, startTime, endTime)) {
curveHistory->addCurve(tr("RRP-Real"), QPen(randomColor(7)), points);
}
}
});
/*
connect(buttonUndo, &QPushButton::clicked, this, [=](){
curveHistory->setNormalScale();
});
*/
// finaly initialize
checkBoxLBPMajor->setChecked(_v_curve_checked[0]);
checkBoxLBPMinor->setChecked(_v_curve_checked[1]);
checkBoxRBPMajor->setChecked(_v_curve_checked[2]);
checkBoxRBPMinor->setChecked(_v_curve_checked[3]);
checkBoxLRPTheory->setChecked(_v_curve_checked[4]);
checkBoxLRPReal->setChecked(_v_curve_checked[5]);
checkBoxRRPTheory->setChecked(_v_curve_checked[6]);
checkBoxRRPReal->setChecked(_v_curve_checked[7]);
}
QWidget* XletQueuesConfigure::buildConfigureQueueList(QWidget *parent)
{
QWidget *root = new QWidget(parent);
QGridLayout *layout = new QGridLayout(root);
root->setLayout(layout);
layout->addWidget(new QLabel(tr("Queue"), root), 0, 0, Qt::AlignLeft);
QLabel *label_qos = new QLabel(tr("Qos - X (s)"), root);
label_qos->setToolTip(tr(
"This is the threshold in seconds to consider that the answer to a "
"call was too late to be accounted as an answer of quality."));
layout->addWidget(label_qos, 0, 1, Qt::AlignLeft);
QLabel *label_window = new QLabel(tr("Window (s)"), root);
label_window->setToolTip(tr(
"The window is the period of time used to compute the statistics"));
layout->addWidget(label_window, 0, 2, Qt::AlignLeft);
QCheckBox *displayQueue;
QSpinBox *spinBox;
int row;
int column;
QVariantMap statConfig = b_engine->getConfig("guioptions.queuespanel").toMap();
QString xqueueid;
row = 1;
QHashIterator<QString, XInfo *> i = \
QHashIterator<QString, XInfo *>(b_engine->iterover("queues"));
while (i.hasNext()) {
column = 0;
i.next();
QueueInfo * queueinfo = (QueueInfo *) i.value();
xqueueid = queueinfo->xid();
displayQueue = new QCheckBox(queueinfo->queueName(), root);
displayQueue->setProperty("xqueueid", xqueueid);
displayQueue->setProperty("param", "visible");
displayQueue->setChecked(statConfig.value("visible" + xqueueid, true).toBool());
layout->addWidget(displayQueue, row, column++);
connect(displayQueue, SIGNAL(stateChanged(int)),
this, SLOT(changeQueueStatParam(int)));
spinBox = new QSpinBox(root);
spinBox->setAlignment(Qt::AlignCenter);
spinBox->setMaximum(240);
spinBox->setProperty("xqueueid", xqueueid);
spinBox->setProperty("param", "xqos");
spinBox->setValue(statConfig.value("xqos" + xqueueid, 60).toInt());
layout->addWidget(spinBox, row, column++);
connect(spinBox, SIGNAL(valueChanged(int)),
this, SLOT(changeQueueStatParam(int)));
spinBox = new QSpinBox(root);
spinBox->setAlignment(Qt::AlignCenter);
spinBox->setMaximum(3600*3);
spinBox->setProperty("xqueueid", xqueueid);
spinBox->setProperty("param", "window");
spinBox->setValue(statConfig.value("window" + xqueueid, 3600).toInt());
layout->addWidget(spinBox, row, column++);
connect(spinBox, SIGNAL(valueChanged(int)),
this, SLOT(changeQueueStatParam(int)));
row++;
}
return root;
}
void ShaderParamsDialog::addShaderParam(struct video_shader_parameter *param, QFormLayout *form)
{
QString desc = param->desc;
QString parameter = param->id;
QLabel *label = new QLabel(desc);
label->setProperty("parameter", parameter);
label->setContextMenuPolicy(Qt::CustomContextMenu);
connect(label, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(onParameterLabelContextMenuRequested(const QPoint&)));
if ((param->minimum == 0.0)
&& (param->maximum
== (param->minimum
+ param->step)))
{
/* option is basically a bool, so use a checkbox */
QCheckBox *checkBox = new QCheckBox(this);
checkBox->setChecked(param->current == param->maximum ? true : false);
checkBox->setProperty("param", parameter);
connect(checkBox, SIGNAL(clicked()), this, SLOT(onShaderParamCheckBoxClicked()));
form->addRow(label, checkBox);
}
else
{
QDoubleSpinBox *doubleSpinBox = NULL;
QSpinBox *spinBox = NULL;
QHBoxLayout *box = new QHBoxLayout();
QSlider *slider = new QSlider(Qt::Horizontal, this);
double value = MainWindow::lerp(param->minimum, param->maximum, 0, 100, param->current);
double intpart = 0;
bool stepIsFractional = modf(param->step, &intpart);
slider->setRange(0, 100);
slider->setSingleStep(1);
slider->setValue(value);
slider->setProperty("param", parameter);
struct video_shader *video_shader = NULL;
getShaders(NULL, &video_shader);
connect(slider, SIGNAL(valueChanged(int)), this, SLOT(onShaderParamSliderValueChanged(int)));
box->addWidget(slider);
if (stepIsFractional)
{
doubleSpinBox = new QDoubleSpinBox(this);
doubleSpinBox->setRange(param->minimum, param->maximum);
doubleSpinBox->setSingleStep(param->step);
doubleSpinBox->setValue(param->current);
doubleSpinBox->setProperty("slider", QVariant::fromValue(slider));
slider->setProperty("doubleSpinBox", QVariant::fromValue(doubleSpinBox));
connect(doubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onShaderParamDoubleSpinBoxValueChanged(double)));
box->addWidget(doubleSpinBox);
}
else
{
spinBox = new QSpinBox(this);
spinBox->setRange(param->minimum, param->maximum);
spinBox->setSingleStep(param->step);
spinBox->setValue(param->current);
spinBox->setProperty("slider", QVariant::fromValue(slider));
slider->setProperty("spinBox", QVariant::fromValue(spinBox));
connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(onShaderParamSpinBoxValueChanged(int)));
box->addWidget(spinBox);
}
form->addRow(label, box);
}
MetadataConfig::MetadataConfig( QWidget *parent )
: ConfigDialogBase( parent )
{
connect( this, SIGNAL(changed()), parent, SLOT(updateButtons()) );
setupUi( this );
m_writeBackCoverDimensions->addItem(
i18nc("Maximum cover size option", "Small (200 px)" ), QVariant( 200 ) );
m_writeBackCoverDimensions->addItem(
i18nc("Maximum cover size option", "Medium (400 px)" ), QVariant( 400 ) );
m_writeBackCoverDimensions->addItem(
i18nc("Maximum cover size option", "Large (800 px)" ), QVariant( 800 ) );
m_writeBackCoverDimensions->addItem(
i18nc("Maximum cover size option", "Huge (1600 px)" ), QVariant( 1600 ) );
m_writeBack->setChecked( AmarokConfig::writeBack() );
m_writeBack->setVisible( false ); // probably not a usecase
m_writeBackStatistics->setChecked( AmarokConfig::writeBackStatistics() );
m_writeBackStatistics->setEnabled( m_writeBack->isChecked() );
m_writeBackCover->setChecked( AmarokConfig::writeBackCover() );
m_writeBackCover->setEnabled( m_writeBack->isChecked() );
if( m_writeBackCoverDimensions->findData( AmarokConfig::writeBackCoverDimensions() ) != -1 )
m_writeBackCoverDimensions->setCurrentIndex( m_writeBackCoverDimensions->findData( AmarokConfig::writeBackCoverDimensions() ) );
else
m_writeBackCoverDimensions->setCurrentIndex( 1 ); // medium
m_writeBackCoverDimensions->setEnabled( m_writeBackCover->isEnabled() && m_writeBackCover->isChecked() );
m_useCharsetDetector->setChecked( AmarokConfig::useCharsetDetector() );
connect( m_writeBack, SIGNAL(toggled(bool)), this, SIGNAL(changed()) );
connect( m_writeBackStatistics, SIGNAL(toggled(bool)), this, SIGNAL(changed()) );
connect( m_writeBackCover, SIGNAL(toggled(bool)), this, SIGNAL(changed()) );
connect( m_writeBackCoverDimensions, SIGNAL(currentIndexChanged(int)), this, SIGNAL(changed()) );
connect( m_useCharsetDetector, SIGNAL(toggled(bool)), this, SIGNAL(changed()) );
StatSyncing::Controller *controller = Amarok::Components::statSyncingController();
StatSyncing::Config *config = controller ? controller->config() : 0;
m_statSyncingConfig = config;
m_statSyncingProvidersView->setModel( config );
m_synchronizeButton->setIcon( KIcon( "amarok_playcount" ) );
m_configureTargetButton->setIcon( KIcon( "configure" ) );
connect( config, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SIGNAL(changed()) );
connect( config, SIGNAL(rowsInserted(QModelIndex,int,int)), SIGNAL(changed()) );
connect( config, SIGNAL(rowsRemoved(QModelIndex,int,int)), SIGNAL(changed()) );
connect( config, SIGNAL(modelReset()), SIGNAL(changed()) );
// Add target button
m_addTargetButton->setEnabled( controller && controller->hasProviderFactories() );
connect( m_addTargetButton, SIGNAL(clicked(bool)), SLOT(slotCreateProviderDialog()) );
// Configure target button
m_configureTargetButton->setEnabled( false );
connect( m_statSyncingProvidersView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
SLOT(slotUpdateProviderConfigureButton()) );
connect( m_configureTargetButton, SIGNAL(clicked(bool)), SLOT(slotConfigureProvider()) );
// Forget target button
connect( m_statSyncingProvidersView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
SLOT(slotUpdateForgetButton()) );
connect( m_forgetTargetsButton, SIGNAL(clicked(bool)), SLOT(slotForgetCollections()) );
// Synchronize button
if( controller )
connect( m_synchronizeButton, SIGNAL(clicked(bool)), controller, SLOT(synchronize()) );
else
m_synchronizeButton->setEnabled( false );
slotUpdateForgetButton();
const qint64 checkedFields = config ? config->checkedFields() : 0;
QMap<qint64, QString> i18nSyncLabels; // to avoid word puzzles, bug 334561
i18nSyncLabels.insert( Meta::valRating, i18nc( "Statistics sync checkbox label",
"Synchronize Ratings" ) );
i18nSyncLabels.insert( Meta::valFirstPlayed, i18nc( "Statistics sync checkbox label",
"Synchronize First Played Times" ) );
i18nSyncLabels.insert( Meta::valLastPlayed, i18nc( "Statistics sync checkbox label",
"Synchronize Last Played Times" ) );
i18nSyncLabels.insert( Meta::valPlaycount, i18nc( "Statistics sync checkbox label",
"Synchronize Playcounts" ) );
i18nSyncLabels.insert( Meta::valLabel, i18nc( "Statistics sync checkbox label",
"Synchronize Labels" ) );
foreach( qint64 field, StatSyncing::Controller::availableFields() )
{
QString name = i18nSyncLabels.value( field );
if( name.isEmpty() )
{
name = i18nc( "%1 is field name such as Play Count (this string is only used "
"as a fallback)", "Synchronize %1", Meta::i18nForField( field ) );
warning() << Q_FUNC_INFO << "no explicit traslation for" << name << "using fallback";
}
QCheckBox *checkBox = new QCheckBox( name );
if( field == Meta::valLabel ) // special case, we want plural:
{
QHBoxLayout *lineLayout = new QHBoxLayout();
QLabel *button = new QLabel();
button->setObjectName( "configureLabelExceptions" );
connect( button, SIGNAL(linkActivated(QString)),
SLOT(slotConfigureExcludedLabels()) );
lineLayout->addWidget( checkBox );
lineLayout->addWidget( button );
lineLayout->addItem( new QSpacerItem( 0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum ) );
m_statSyncingFieldsLayout->addLayout( lineLayout );
slotUpdateConfigureExcludedLabelsLabel();
}
else
{
m_statSyncingFieldsLayout->addWidget( checkBox );
}
checkBox->setCheckState( ( field & checkedFields ) ? Qt::Checked : Qt::Unchecked );
checkBox->setProperty( "field", field );
connect( checkBox, SIGNAL(stateChanged(int)), SIGNAL(changed()) );
}
void ParamWidget::AddBooleans(const std::vector<BoolItem>& to_add,
DisplayHint display_hint) {
if (display_hint != kCheckBox) {
throw std::invalid_argument("Invalid display hint");
}
QWidget* row_widget = new QWidget(this);
QHBoxLayout* hbox = new QHBoxLayout(row_widget);
for (const BoolItem& item : to_add) {
ExpectNameNotFound(item.name);
QCheckBox* checkbox =
new QCheckBox(item.name, this);
if (item.initially_checked) {
checkbox->setCheckState(Qt::Checked);
} else {
checkbox->setCheckState(Qt::Unchecked);
}
checkbox->setProperty("param_widget_type", kParamBool);
widgets_[item.name] = checkbox;
hbox->addWidget(checkbox);
connect(checkbox, &QCheckBox::stateChanged,
[this, item](int val) { emit ParamChanged(item.name); });
}
layout_->addWidget(row_widget);
}
