mirror/yacreader
1
0
Fork 0
mirror of https://github.com/YACReader/yacreader synced 2025-06-04 01:28:55 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity
yacreader/YACReaderLibrary/options_dialog.cpp
Luis Ángel San Martín 5d13a4812a a?adido soporte para la configuraci?n del comic flow 
a?adido soporte para la configuraci?n de la calidad del comic flow

primera versi?n del di?logo de configuraci?n del servidor implementada
2012-10-08 07:38:34 +02:00

567 lines
19 KiB
C++
Raw Blame History

#include "options_dialog.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QFileDialog>
#include <QGroupBox>
#include <QRadioButton>
#include <QTextStream>
#include <QCoreApplication>
#include <QFile>
#include <QMessageBox>
#include <QCheckBox>
#include "custom_widgets.h"
#include "yacreader_flow_gl.h"
PictureFlow::FlowType flowType = PictureFlow::Strip;
OptionsDialog::OptionsDialog(QWidget * parent)
:QDialog()
{
QVBoxLayout * layout = new QVBoxLayout;
QLayout * layout1 = setupLayoutSW();
QLayout * layout2 = setupLayoutGL();
sw = new QWidget(this);
layout1->setContentsMargins(0,0,0,0);
sw->setLayout(layout1);
gl = new QWidget(this);
layout2->setContentsMargins(0,0,0,0);
gl->setLayout(layout2);
QHBoxLayout * switchFlowType = new QHBoxLayout;
switchFlowType->addStretch();
switchFlowType->addWidget(useGL = new QCheckBox(tr("Use hardware acceleration (restart needed)")));
connect(useGL,SIGNAL(stateChanged(int)),this,SLOT(saveUseGL(int)));
accept = new QPushButton(tr("Save"));
cancel = new QPushButton(tr("Cancel"));
connect(accept,SIGNAL(clicked()),this,SLOT(saveOptions()));
connect(cancel,SIGNAL(clicked()),this,SLOT(restoreOptions()));
connect(cancel,SIGNAL(clicked()),this,SLOT(close()));
QHBoxLayout * buttons = new QHBoxLayout();
buttons->addStretch();
buttons->addWidget(accept);
buttons->addWidget(cancel);
layout->addWidget(sw);
layout->addWidget(gl);
layout->addLayout(switchFlowType);
layout->addLayout(buttons);
sw->hide();
setLayout(layout);
//restoreOptions(settings); //load options
//resize(200,0);
setModal (true);
setWindowTitle("Options");
}
QLayout * OptionsDialog::setupLayoutSW()
{
QVBoxLayout * layout = new QVBoxLayout(this);
QGroupBox *groupBox = new QGroupBox(tr("How to show covers:"));
radio1 = new QRadioButton(tr("CoverFlow look"));
radio2 = new QRadioButton(tr("Stripe look"));
radio3 = new QRadioButton(tr("Overlapped Stripe look"));
QVBoxLayout *vbox = new QVBoxLayout;
QHBoxLayout * opt1 = new QHBoxLayout;
opt1->addWidget(radio1);
QLabel * lOpt1 = new QLabel();
lOpt1->setPixmap(QPixmap(":/images/flow1.png"));
opt1->addStretch();
opt1->addWidget(lOpt1);
vbox->addLayout(opt1);
QHBoxLayout * opt2 = new QHBoxLayout;
opt2->addWidget(radio2);
QLabel * lOpt2 = new QLabel();
lOpt2->setPixmap(QPixmap(":/images/flow2.png"));
opt2->addStretch();
opt2->addWidget(lOpt2);
vbox->addLayout(opt2);
QHBoxLayout * opt3 = new QHBoxLayout;
opt3->addWidget(radio3);
QLabel * lOpt3 = new QLabel();
lOpt3->setPixmap(QPixmap(":/images/flow3.png"));
opt3->addStretch();
opt3->addWidget(lOpt3);
vbox->addLayout(opt3);
//vbox->addStretch(1);
groupBox->setLayout(vbox);
layout->addWidget(groupBox);
return layout;
}
QLayout * OptionsDialog::setupLayoutGL()
{
QVBoxLayout * layout = new QVBoxLayout(this);
//PRESETS------------------------------------------------------------------
QGroupBox *groupBox = new QGroupBox(tr("Presets:"));
radioClassic = new QRadioButton(tr("Classic look"));
connect(radioClassic,SIGNAL(toggled(bool)),this,SLOT(setClassicConfig()));
radioStripe = new QRadioButton(tr("Stripe look"));
connect(radioStripe,SIGNAL(toggled(bool)),this,SLOT(setStripeConfig()));
radioOver = new QRadioButton(tr("Overlapped Stripe look"));
connect(radioOver,SIGNAL(toggled(bool)),this,SLOT(setOverlappedStripeConfig()));
radionModern = new QRadioButton(tr("Modern look"));
connect(radionModern,SIGNAL(toggled(bool)),this,SLOT(setModernConfig()));
radioDown = new QRadioButton(tr("Roulette look"));
connect(radioDown,SIGNAL(toggled(bool)),this,SLOT(setRouletteConfig()));
QVBoxLayout *vbox = new QVBoxLayout;
QHBoxLayout * opt1 = new QHBoxLayout;
opt1->addWidget(radioClassic);
QLabel * lOpt1 = new QLabel();
lOpt1->setPixmap(QPixmap(":/images/flow1.png"));
opt1->addStretch();
opt1->addWidget(lOpt1);
vbox->addLayout(opt1);
QHBoxLayout * opt2 = new QHBoxLayout;
opt2->addWidget(radioStripe);
QLabel * lOpt2 = new QLabel();
lOpt2->setPixmap(QPixmap(":/images/flow2.png"));
opt2->addStretch();
opt2->addWidget(lOpt2);
vbox->addLayout(opt2);
QHBoxLayout * opt3 = new QHBoxLayout;
opt3->addWidget(radioOver);
QLabel * lOpt3 = new QLabel();
lOpt3->setPixmap(QPixmap(":/images/flow3.png"));
opt3->addStretch();
opt3->addWidget(lOpt3);
vbox->addLayout(opt3);
QHBoxLayout * opt4 = new QHBoxLayout;
opt4->addWidget(radionModern);
QLabel * lOpt4 = new QLabel();
lOpt4->setPixmap(QPixmap(":/images/flow3.png"));
opt4->addStretch();
opt4->addWidget(lOpt4);
vbox->addLayout(opt4);
QHBoxLayout * opt5 = new QHBoxLayout;
opt5->addWidget(radioDown);
QLabel * lOpt5 = new QLabel();
lOpt5->setPixmap(QPixmap(":/images/flow3.png"));
opt5->addStretch();
opt5->addWidget(lOpt5);
vbox->addLayout(opt5);
groupBox->setLayout(vbox);
//OPTIONS------------------------------------------------------------------
QGroupBox *optionsGroupBox = new QGroupBox(tr("Custom:"));
xRotation = new YACReaderSpinSliderWidget(this);
xRotation->setText(tr("View angle"));
xRotation->setRange(0,90);
connect(xRotation,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(xRotation,SIGNAL(valueChanged(int)),this,SLOT(saveXRotation(int)));
yPosition = new YACReaderSpinSliderWidget(this);
yPosition->setText(tr("Position"));
yPosition->setRange(-100,100);
connect(yPosition,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(yPosition,SIGNAL(valueChanged(int)),this,SLOT(saveYPosition(int)));
coverDistance = new YACReaderSpinSliderWidget(this);
coverDistance->setText(tr("Cover gap"));
coverDistance->setRange(0,150);
connect(coverDistance,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(coverDistance,SIGNAL(valueChanged(int)),this,SLOT(saveCoverDistance(int)));
centralDistance = new YACReaderSpinSliderWidget(this);
centralDistance->setText(tr("Central gap"));
centralDistance->setRange(0,150);
connect(centralDistance,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(centralDistance,SIGNAL(valueChanged(int)),this,SLOT(saveCentralDistance(int)));
zoomLevel = new YACReaderSpinSliderWidget(this);
zoomLevel->setText(tr("Zoom"));
zoomLevel->setRange(-20,0);
connect(zoomLevel,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(zoomLevel,SIGNAL(valueChanged(int)),this,SLOT(saveZoomLevel(int)));
yCoverOffset = new YACReaderSpinSliderWidget(this);
yCoverOffset->setText(tr("Y offset"));
yCoverOffset->setRange(-50,50);
connect(yCoverOffset,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(yCoverOffset,SIGNAL(valueChanged(int)),this,SLOT(saveYCoverOffset(int)));
zCoverOffset = new YACReaderSpinSliderWidget(this);
zCoverOffset->setText(tr("Z offset"));
zCoverOffset->setRange(-50,50);
connect(zCoverOffset,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(zCoverOffset,SIGNAL(valueChanged(int)),this,SLOT(saveZCoverOffset(int)));
coverRotation = new YACReaderSpinSliderWidget(this);
coverRotation->setText(tr("Cover Angle"));
coverRotation->setRange(0,360);
connect(coverRotation,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(coverRotation,SIGNAL(valueChanged(int)),this,SLOT(saveCoverRotation(int)));
fadeOutDist = new YACReaderSpinSliderWidget(this);
fadeOutDist->setText(tr("Visibility"));
fadeOutDist->setRange(0,10);
connect(fadeOutDist,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(fadeOutDist,SIGNAL(valueChanged(int)),this,SLOT(saveFadeOutDist(int)));
lightStrength = new YACReaderSpinSliderWidget(this);
lightStrength->setText(tr("Light"));
lightStrength->setRange(-10,10);
connect(lightStrength,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(lightStrength,SIGNAL(valueChanged(int)),this,SLOT(saveLightStrength(int)));
maxAngle = new YACReaderSpinSliderWidget(this);
maxAngle->setText(tr("Max angle"));
maxAngle->setRange(0,90);
connect(maxAngle,SIGNAL(valueChanged(int)),this,SIGNAL(optionsChanged()));
connect(maxAngle,SIGNAL(valueChanged(int)),this,SLOT(saveMaxAngle(int)));
QVBoxLayout *optionsLayoutStretch = new QVBoxLayout;
optionsLayoutStretch->setContentsMargins(0,0,0,0);
QGridLayout *optionsLayout = new QGridLayout;
optionsLayout->addWidget(xRotation,0,0);
optionsLayout->addWidget(yPosition,0,1);
optionsLayout->addWidget(coverDistance,1,0);
optionsLayout->addWidget(centralDistance,1,1);
optionsLayout->addWidget(zoomLevel,2,0);
optionsLayout->addWidget(yCoverOffset,2,1);
optionsLayout->addWidget(zCoverOffset,3,0);
optionsLayout->addWidget(coverRotation,3,1);
optionsLayout->addWidget(fadeOutDist,4,0);
optionsLayout->addWidget(lightStrength,4,1);
optionsLayout->addWidget(maxAngle,5,0);
optionsLayoutStretch->addLayout(optionsLayout);
optionsLayoutStretch->addStretch();
optionsGroupBox->setLayout(optionsLayoutStretch);
QHBoxLayout * groupBoxesLayout = new QHBoxLayout;
groupBoxesLayout->addWidget(groupBox);
groupBoxesLayout->addWidget(optionsGroupBox);
QHBoxLayout * performance = new QHBoxLayout;
performance->addWidget(new QLabel(tr("Low Performance")));
performance->addWidget(performanceSlider = new QSlider(Qt::Horizontal));
performance->addWidget(new QLabel(tr("High Performance")));
performanceSlider->setMinimum(0);
performanceSlider->setMaximum(3);
performanceSlider->setSingleStep(1);
performanceSlider->setPageStep(1);
performanceSlider->setTickInterval(1);
performanceSlider->setTickPosition(QSlider::TicksRight);
connect(performanceSlider, SIGNAL(valueChanged(int)),this,SLOT(savePerformance(int)));
connect(performanceSlider, SIGNAL(valueChanged(int)),this,SLOT(optionsChanged()));
layout->addLayout(groupBoxesLayout);
layout->addLayout(performance);
return layout;
}
void OptionsDialog::savePerformance(int value)
{
settings->setValue("performance",value);
}
void OptionsDialog::saveUseGL(int b)
{
if(Qt::Checked == b)
{
sw->setVisible(false);
gl->setVisible(true);
}
else
{
gl->setVisible(false);
sw->setVisible(true);
}
resize(0,0);
settings->setValue("useOpenGL",b);
}
void OptionsDialog::saveXRotation(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("xRotation",xRotation->getValue());
}
void OptionsDialog::saveYPosition(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("yPosition",yPosition->getValue());
}
void OptionsDialog::saveCoverDistance(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("coverDistance",coverDistance->getValue());
}
void OptionsDialog::saveCentralDistance(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("centralDistance",centralDistance->getValue());
}
void OptionsDialog::saveZoomLevel(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("zoomLevel",zoomLevel->getValue());
}
void OptionsDialog::saveYCoverOffset(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("yCoverOffset",yCoverOffset->getValue());
}
void OptionsDialog::saveZCoverOffset(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("zCoverOffset",zCoverOffset->getValue());
}
void OptionsDialog::saveCoverRotation(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("coverRotation",coverRotation->getValue());
}
void OptionsDialog::saveFadeOutDist(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("fadeOutDist",fadeOutDist->getValue());
}
void OptionsDialog::saveLightStrength(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("lightStrength",lightStrength->getValue());
}
void OptionsDialog::saveMaxAngle(int value)
{
settings->setValue("flowType",PictureFlow::Custom);
settings->setValue("maxAngle",maxAngle->getValue());
}
void OptionsDialog::saveOptions()
{
emit(optionsChanged());
close();
}
void OptionsDialog::restoreOptions(QSettings * settings)
{
this->settings = settings;
if(settings->contains("useOpenGL") && settings->value("useOpenGL").toInt() == Qt::Checked)
{
sw->setVisible(false);
gl->setVisible(true);
useGL->setChecked(true);
}
else
{
gl->setVisible(false);
sw->setVisible(true);
useGL->setChecked(false);
}
if(!settings->contains("flowType"))
{
setClassicConfig();
radioClassic->setChecked(true);
performanceSlider->setValue(1);
return;
}
performanceSlider->setValue(settings->value("performance").toInt());
PictureFlow::FlowType flowType;
switch(settings->value("flowType").toInt())
{
case 0:
flowType = PictureFlow::CoverFlowLike;
break;
case 1:
flowType = PictureFlow::Strip;
break;
case 2:
flowType = PictureFlow::StripOverlapped;
break;
case 3:
flowType = PictureFlow::Modern;
break;
case 4:
flowType = PictureFlow::Roulette;
break;
case 5:
flowType = PictureFlow::Custom;
break;
}
if(flowType == PictureFlow::Custom)
{
loadConfig();
return;
}
if(flowType == PictureFlow::CoverFlowLike)
{
setClassicConfig();
radioClassic->setChecked(true);
return;
}
if(flowType == PictureFlow::Strip)
{
setStripeConfig();
radioStripe->setChecked(true);
return;
}
if(flowType == PictureFlow::StripOverlapped)
{
setOverlappedStripeConfig();
radioOver->setChecked(true);
return;
}
if(flowType == PictureFlow::Modern)
{
setModernConfig();
radionModern->setChecked(true);
return;
}
if(flowType == PictureFlow::Roulette)
{
setRouletteConfig();
radioDown->setChecked(true);
return;
}
}
void OptionsDialog::loadConfig()
{
xRotation->setValue(settings->value("xRotation").toInt());
yPosition->setValue(settings->value("yPosition").toInt());
coverDistance->setValue(settings->value("coverDistance").toInt());
centralDistance->setValue(settings->value("centralDistance").toInt());
zoomLevel->setValue(settings->value("zoomLevel").toInt());
yCoverOffset->setValue(settings->value("yCoverOffset").toInt());
zCoverOffset->setValue(settings->value("zCoverOffset").toInt());
coverRotation->setValue(settings->value("coverRotation").toInt());
fadeOutDist->setValue(settings->value("fadeOutDist").toInt());
lightStrength->setValue(settings->value("lightStrength").toInt());
maxAngle->setValue(settings->value("maxAngle").toInt());
}
void OptionsDialog::setClassicConfig()
{
settings->setValue("flowType",PictureFlow::CoverFlowLike);
xRotation->setValue(presetYACReaderFlowClassicConfig.cfRX);
yPosition->setValue(presetYACReaderFlowClassicConfig.cfY*100);
coverDistance->setValue(presetYACReaderFlowClassicConfig.xDistance*100);
centralDistance->setValue(presetYACReaderFlowClassicConfig.centerDistance*100);
zoomLevel->setValue(presetYACReaderFlowClassicConfig.cfZ);
yCoverOffset->setValue(presetYACReaderFlowClassicConfig.yDistance*100);
zCoverOffset->setValue(presetYACReaderFlowClassicConfig.zDistance*100);
coverRotation->setValue(presetYACReaderFlowClassicConfig.rotation*-1);
fadeOutDist->setValue(presetYACReaderFlowClassicConfig.animationFadeOutDist);
lightStrength->setValue(presetYACReaderFlowClassicConfig.viewRotateLightStrenght);
maxAngle->setValue(presetYACReaderFlowClassicConfig.viewAngle);
}
void OptionsDialog::setStripeConfig()
{
settings->setValue("flowType",PictureFlow::Strip);
xRotation->setValue(presetYACReaderFlowStripeConfig.cfRX);
yPosition->setValue(presetYACReaderFlowStripeConfig.cfY*100);
coverDistance->setValue(presetYACReaderFlowStripeConfig.xDistance*100);
centralDistance->setValue(presetYACReaderFlowStripeConfig.centerDistance*100);
zoomLevel->setValue(presetYACReaderFlowStripeConfig.cfZ);
yCoverOffset->setValue(presetYACReaderFlowStripeConfig.yDistance*100);
zCoverOffset->setValue(presetYACReaderFlowStripeConfig.zDistance*100);
coverRotation->setValue(presetYACReaderFlowStripeConfig.rotation*-1);
fadeOutDist->setValue(presetYACReaderFlowStripeConfig.animationFadeOutDist);
lightStrength->setValue(presetYACReaderFlowStripeConfig.viewRotateLightStrenght);
maxAngle->setValue(presetYACReaderFlowStripeConfig.viewAngle);
}
void OptionsDialog::setOverlappedStripeConfig()
{
settings->setValue("flowType",PictureFlow::StripOverlapped);
xRotation->setValue(presetYACReaderFlowOverlappedStripeConfig.cfRX);
yPosition->setValue(presetYACReaderFlowOverlappedStripeConfig.cfY*100);
coverDistance->setValue(presetYACReaderFlowOverlappedStripeConfig.xDistance*100);
centralDistance->setValue(presetYACReaderFlowOverlappedStripeConfig.centerDistance*100);
zoomLevel->setValue(presetYACReaderFlowOverlappedStripeConfig.cfZ);
yCoverOffset->setValue(presetYACReaderFlowOverlappedStripeConfig.yDistance*100);
zCoverOffset->setValue(presetYACReaderFlowOverlappedStripeConfig.zDistance*100);
coverRotation->setValue(presetYACReaderFlowOverlappedStripeConfig.rotation*-1);
fadeOutDist->setValue(presetYACReaderFlowOverlappedStripeConfig.animationFadeOutDist);
lightStrength->setValue(presetYACReaderFlowOverlappedStripeConfig.viewRotateLightStrenght);
maxAngle->setValue(presetYACReaderFlowOverlappedStripeConfig.viewAngle);
}
void OptionsDialog::setModernConfig()
{
settings->setValue("flowType",PictureFlow::Modern);
xRotation->setValue(defaultYACReaderFlowConfig.cfRX);
yPosition->setValue(defaultYACReaderFlowConfig.cfY*100);
coverDistance->setValue(defaultYACReaderFlowConfig.xDistance*100);
centralDistance->setValue(defaultYACReaderFlowConfig.centerDistance*100);
zoomLevel->setValue(defaultYACReaderFlowConfig.cfZ);
yCoverOffset->setValue(defaultYACReaderFlowConfig.yDistance*100);
zCoverOffset->setValue(defaultYACReaderFlowConfig.zDistance*100);
coverRotation->setValue(defaultYACReaderFlowConfig.rotation*-1);
fadeOutDist->setValue(defaultYACReaderFlowConfig.animationFadeOutDist);
lightStrength->setValue(defaultYACReaderFlowConfig.viewRotateLightStrenght);
maxAngle->setValue(defaultYACReaderFlowConfig.viewAngle);
}
void OptionsDialog::setRouletteConfig()
{
settings->setValue("flowType",PictureFlow::Roulette);
xRotation->setValue(pressetYACReaderFlowDownConfig.cfRX);
yPosition->setValue(pressetYACReaderFlowDownConfig.cfY*100);
coverDistance->setValue(pressetYACReaderFlowDownConfig.xDistance*100);
centralDistance->setValue(pressetYACReaderFlowDownConfig.centerDistance*100);
zoomLevel->setValue(pressetYACReaderFlowDownConfig.cfZ);
yCoverOffset->setValue(pressetYACReaderFlowDownConfig.yDistance*100);
zCoverOffset->setValue(pressetYACReaderFlowDownConfig.zDistance*100);
coverRotation->setValue(pressetYACReaderFlowDownConfig.rotation*-1);
fadeOutDist->setValue(pressetYACReaderFlowDownConfig.animationFadeOutDist);
lightStrength->setValue(pressetYACReaderFlowDownConfig.viewRotateLightStrenght);
maxAngle->setValue(pressetYACReaderFlowDownConfig.viewAngle);
}
Reference in New Issue View Git Blame Copy Permalink