#include "toonzqt/camerasettingswidget.h"

// TnzQt includes

#include "toonzqt/doublefield.h"

#include "toonzqt/intfield.h"

#include "toonzqt/lineedit.h"

#include "toonzqt/checkbox.h"

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/dvdialog.h"

// TnzLib includes

#include "toonz/toonzfolders.h"

#include "toonz/tcamera.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/txshlevel.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshleveltypes.h"

// TnzCore includes

#include "tconvert.h"

#include "tsystem.h"

#include "tfilepath_io.h"

#include "tutil.h"

// Qt includes

#include <qgridlayout></qgridlayout>

#include <qlabel></qlabel>

#include <qgridlayout></qgridlayout>

#include <qradiobutton></qradiobutton>

#include <qbuttongroup></qbuttongroup>

#include <qapplication></qapplication>

#include <qcombobox></qcombobox>

#include <qmessagebox></qmessagebox>

#include <qlist></qlist>

#include <qstringlist></qstringlist>

#include <qregexp></qregexp>

#include <qpainter></qpainter>

#include <qtextstream></qtextstream>

#include <qstring></qstring>

#include <qstringlist></qstringlist>

using namespace std;

using namespace DVGui;

namespace

{

// the first value in the preset list

const QString custom = QObject::tr("<custom>");</custom>

/*---小数の余分なゼロを消す---*/

QString removeZeros(QString srcStr)

{

	if (!srcStr.contains('.'))

		return srcStr;

	for (int i = srcStr.length() - 1; i >= 0; i--) {

		if (srcStr.at(i) == '0')

			srcStr.chop(1);

		else if (srcStr.at(i) == '.') {

			srcStr.chop(1);

			break;

		} else

			break;

	}

	return srcStr;

}

} // namespace

//=============================================================================

QValidator::State SimpleExpValidator::validate(QString &input, int &pos) const

{

	/*---使用可能な文字---*/

	QString validChars("0123456789/.");

	int slashCount = 0;

	for (int i = 0; i < input.length(); i++) {

		/*--- まず、使用不可能な文字が含まれている場合はInvalid ---*/

		if (!validChars.contains(input.at(i)))

			return Invalid;

		if (input.at(i) == '/')

			slashCount++;

	}

	/*--- 中身は普通の数字。Doubleに変換可能ならOK ---*/

	if (slashCount == 0) {

		bool ok;

		double tmp = input.toDouble(&ok);

		if (ok)

			return (tmp > 0) ? Acceptable : Intermediate;

		else

			return Intermediate;

	} else if (slashCount >= 2) {

		return Intermediate;

	} else //slashCount == 1

	{

		if (input.at(0) == '/' || input.at(input.length() - 1) == '/')

			return Intermediate;

		else {

			QStringList strList = input.split('/');

			/*--- スラッシュの左右でDoubleに変換できるかチェック。できないとIntermediate。 ---*/

			for (int i = 0; i < strList.size(); i++) {

				QString tmpStr = strList.at(i);

				bool ok;

				double tmp = tmpStr.toDouble(&ok);

				if (!ok)

					return Intermediate;

				if (ok && tmp <= 0)

					return Intermediate;

			}

			/*--- 左右でDoubleに変換できたのでOK ---*/

			return Acceptable;

		}

	}

}

//=============================================================================

SimpleExpField::SimpleExpField(QWidget *parent)

	: QLineEdit(parent)

{

	m_validator = new SimpleExpValidator(this);

	setValidator(m_validator);

}

//--------------------------------------------------------------------------

/*--- 普通に値を入れる ---*/

void SimpleExpField::setValue(double value)

{

	QString str;

	str.setNum(value);

	setText(str);

}

//--------------------------------------------------------------------------

/*--- A/R用 valueがw/hに近ければ "w/h" という文字列を入れる ---*/

void SimpleExpField::setValue(double value, int w, int h)

{

	QString str;

	if (areAlmostEqual(value, (double)w / (double)h, 1e-5))

		str = QString().setNum(w) + "/" + QString().setNum(h);

	else

		str.setNum(value);

	setText(str);

}

//--------------------------------------------------------------------------

double SimpleExpField::getValue()

{

	int slashCount = text().count('/');

	if (slashCount == 0)

		return text().toDouble();

	else if (slashCount == 1) {

		QStringList strList = text().split('/');

		return strList.at(0).toDouble() / strList.at(1).toDouble();

	}

	std::cout << "more than one slash!" << std::endl;

	return 0.1;

}

//--------------------------------------------------------------------------

void SimpleExpField::focusInEvent(QFocusEvent *event)

{

	m_previousValue = text();

	QLineEdit::focusInEvent(event);

}

//--------------------------------------------------------------------------

void SimpleExpField::focusOutEvent(QFocusEvent *event)

{

	int dummy;

	QString tmp = text();

	if (validator()->validate(tmp, dummy) != QValidator::Acceptable)

		setText(m_previousValue);

	QLineEdit::focusOutEvent(event);

}

//=============================================================================

CameraSettingsWidget::CameraSettingsWidget(bool forCleanup)

	: m_forCleanup(forCleanup), m_arValue(0), m_presetListFile(""), m_currentLevel(0)

{

	m_xPrev = new QRadioButton();

	m_yPrev = new QRadioButton();

	m_arPrev = new QRadioButton();

	m_inchPrev = new QRadioButton();

	m_dotPrev = new QRadioButton();

	m_lxFld = new MeasuredDoubleLineEdit();

	m_lyFld = new MeasuredDoubleLineEdit();

	m_arFld = new SimpleExpField(this);

	m_xResFld = new DVGui::IntLineEdit();

	m_yResFld = new DVGui::IntLineEdit();

	m_xDpiFld = new DoubleLineEdit();

	m_yDpiFld = new DoubleLineEdit();

	m_fspChk = new QPushButton("");

	m_useLevelSettingsBtn = new QPushButton(tr("Use Current Level Settings"));

	m_presetListOm = new QComboBox();

	m_addPresetBtn = new QPushButton(tr("Add"));

	m_removePresetBtn = new QPushButton(tr("Remove"));

	//----

	m_useLevelSettingsBtn->setEnabled(false);

	m_useLevelSettingsBtn->setFocusPolicy(Qt::NoFocus);

	m_lxFld->installEventFilter(this);

	m_lyFld->installEventFilter(this);

	m_arFld->installEventFilter(this);

	m_xResFld->installEventFilter(this);

	m_yResFld->installEventFilter(this);

	m_xDpiFld->installEventFilter(this);

	m_yDpiFld->installEventFilter(this);

	m_xResFld->setMinimumWidth(0);

	m_xResFld->setMaximumWidth(QWIDGETSIZE_MAX);

	m_yResFld->setMinimumWidth(0);

	m_yResFld->setMaximumWidth(QWIDGETSIZE_MAX);

	/*--- 表示精度を4桁にする ---*/

	m_lxFld->setDecimals(4);

	m_lyFld->setDecimals(4);

	m_lxFld->setMeasure("camera.lx");

	m_lyFld->setMeasure("camera.ly");

	m_lxFld->setRange(numeric_limits<double>::epsilon(), numeric_limits<double>::infinity());</double></double>

	m_lyFld->setRange(numeric_limits<double>::epsilon(), numeric_limits<double>::infinity());</double></double>

	m_xResFld->setRange(1, 10000000);

	m_yResFld->setRange(1, 10000000);

	m_xDpiFld->setRange(1, numeric_limits<double>::infinity());</double>

	m_yDpiFld->setRange(1, numeric_limits<double>::infinity());</double>

	m_fspChk->setFixedSize(20, 20);

	m_fspChk->setCheckable(true);

	m_fspChk->setChecked(true);

	m_fspChk->setToolTip(tr("Force Squared Pixel"));

	m_fspChk->setObjectName("ForceSquaredPixelButton");

	m_addPresetBtn->setObjectName("PushButton_NoPadding");

	m_removePresetBtn->setObjectName("PushButton_NoPadding");

	m_inchPrev->setFixedSize(11, 21);

	m_dotPrev->setFixedSize(11, 21);

	m_inchPrev->setObjectName("CameraSettingsRadioButton_Small");

	m_dotPrev->setObjectName("CameraSettingsRadioButton_Small");

	m_xPrev->setObjectName("CameraSettingsRadioButton");

	m_yPrev->setObjectName("CameraSettingsRadioButton");

	m_arPrev->setObjectName("CameraSettingsRadioButton");

	// radio buttons groups

	QButtonGroup *group;

	group = new QButtonGroup;

	group->addButton(m_xPrev);

	group->addButton(m_yPrev);

	group->addButton(m_arPrev);

	group = new QButtonGroup;

	group->addButton(m_inchPrev);

	group->addButton(m_dotPrev);

	m_arPrev->setChecked(true);

	m_dotPrev->setChecked(true);

	//------ layout

	QVBoxLayout *mainLay = new QVBoxLayout();

	mainLay->setSpacing(3);

	mainLay->setMargin(3);

	{

		QGridLayout *gridLay = new QGridLayout();

		gridLay->setHorizontalSpacing(2);

		gridLay->setVerticalSpacing(3);

		{

			gridLay->addWidget(m_xPrev, 0, 2, Qt::AlignCenter);

			gridLay->addWidget(m_yPrev, 0, 4, Qt::AlignCenter);

			gridLay->addWidget(m_inchPrev, 1, 0, Qt::AlignRight | Qt::AlignVCenter);

			gridLay->addWidget(new QLabel("Inch"), 1, 1, Qt::AlignRight | Qt::AlignVCenter);

			gridLay->addWidget(m_lxFld, 1, 2);

			gridLay->addWidget(new QLabel("x"), 1, 3, Qt::AlignCenter);

			gridLay->addWidget(m_lyFld, 1, 4);

			gridLay->addWidget(m_arPrev, 2, 2, Qt::AlignRight | Qt::AlignVCenter);

			gridLay->addWidget(new QLabel("A/R"), 2, 3, Qt::AlignCenter);

			gridLay->addWidget(m_arFld, 2, 4);

			gridLay->addWidget(m_dotPrev, 3, 0, Qt::AlignRight | Qt::AlignVCenter);

			gridLay->addWidget(new QLabel("Pixel"), 3, 1, Qt::AlignRight | Qt::AlignVCenter);

			gridLay->addWidget(m_xResFld, 3, 2);

			gridLay->addWidget(new QLabel("x"), 3, 3, Qt::AlignCenter);

			gridLay->addWidget(m_yResFld, 3, 4);

			gridLay->addWidget(new QLabel("DPI"), 4, 1, Qt::AlignRight | Qt::AlignVCenter);

			gridLay->addWidget(m_xDpiFld, 4, 2);

			gridLay->addWidget(m_fspChk, 4, 3, Qt::AlignCenter);

			gridLay->addWidget(m_yDpiFld, 4, 4);

		}

		gridLay->setColumnStretch(0, 0);

		gridLay->setColumnStretch(1, 0);

		gridLay->setColumnStretch(2, 1);

		gridLay->setColumnStretch(3, 0);

		gridLay->setColumnStretch(4, 1);

		mainLay->addLayout(gridLay);

		mainLay->addWidget(m_useLevelSettingsBtn);

		QHBoxLayout *resListLay = new QHBoxLayout();

		resListLay->setSpacing(3);

		resListLay->setMargin(1);

		{

			resListLay->addWidget(m_presetListOm, 1);

			resListLay->addWidget(m_addPresetBtn, 0);

			resListLay->addWidget(m_removePresetBtn, 0);

		}

		mainLay->addLayout(resListLay);

	}

	setLayout(mainLay);

	// initialize fields

	TCamera camera;

	setFields(&camera);

	// connect events

	bool ret = true;

	ret = ret && connect(m_lxFld, SIGNAL(editingFinished()), SLOT(onLxChanged()));

	ret = ret && connect(m_lyFld, SIGNAL(editingFinished()), SLOT(onLyChanged()));

	ret = ret && connect(m_arFld, SIGNAL(editingFinished()), SLOT(onArChanged()));

	ret = ret && connect(m_xResFld, SIGNAL(editingFinished()), SLOT(onXResChanged()));

	ret = ret && connect(m_yResFld, SIGNAL(editingFinished()), SLOT(onYResChanged()));

	ret = ret && connect(m_xDpiFld, SIGNAL(editingFinished()), SLOT(onXDpiChanged()));

	ret = ret && connect(m_yDpiFld, SIGNAL(editingFinished()), SLOT(onYDpiChanged()));

	ret = ret && connect(m_fspChk, SIGNAL(clicked(bool)), SLOT(onFspChanged(bool)));

	ret = ret && connect(m_xPrev, SIGNAL(toggled(bool)), SLOT(onPrevToggled(bool)));

	ret = ret && connect(m_yPrev, SIGNAL(toggled(bool)), SLOT(onPrevToggled(bool)));

	ret = ret && connect(m_dotPrev, SIGNAL(toggled(bool)), SLOT(onPrevToggled(bool)));

	ret = ret && connect(m_inchPrev, SIGNAL(toggled(bool)), SLOT(onPrevToggled(bool)));

	ret = ret && connect(m_useLevelSettingsBtn, SIGNAL(clicked()), this, SLOT(useLevelSettings()));

	ret = ret && connect(m_presetListOm, SIGNAL(activated(const QString &)),

						 SLOT(onPresetSelected(const QString &)));

	ret = ret && connect(m_addPresetBtn, SIGNAL(clicked()), SLOT(addPreset()));

	ret = ret && connect(m_removePresetBtn, SIGNAL(clicked()), SLOT(removePreset()));

	assert(ret);

}

CameraSettingsWidget::~CameraSettingsWidget()

{

	setCurrentLevel(0);

}

void CameraSettingsWidget::loadPresetList()

{

	if (m_presetListFile == "")

		return;

	m_presetListOm->clear();

	m_presetListOm->addItem(custom);

	QFile file(m_presetListFile);

	if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {

		QTextStream in(&file);

		while (!in.atEnd()) {

			QString line = in.readLine().trimmed();

			if (line != "")

				m_presetListOm->addItem(line);

		}

	}

	m_presetListOm->setCurrentIndex(0);

}

void CameraSettingsWidget::savePresetList()

{

	QFile file(m_presetListFile);

	if (!file.open(QIODevice::WriteOnly | QIODevice::Text))

		return;

	QTextStream out(&file);

	int n = m_presetListOm->count();

	for (int i = 1; i < n; i++)

		out << m_presetListOm->itemText(i) << "\n";

}

bool CameraSettingsWidget::parsePresetString(const QString &str, QString &name, int &xres, int &yres, QString &ar)

{

	// str : name, 1024x768, 4/3

	int b;

	b = str.lastIndexOf(",");

	if (b <= 1)

		return false;

	b = str.lastIndexOf(",", b - 1);

	if (b <= 0)

		return false;

	QRegExp rx(" *([0-9]+)x([0-9]+) *, *(\\d*(\\.\\d+)?|\\d+/\\d+) *");

	if (!rx.exactMatch(str.mid(b + 1)))

		return false;

	name = b > 0 ? str.left(b).trimmed() : "";

	xres = rx.cap(1).toInt();

	yres = rx.cap(2).toInt();

	ar = rx.cap(3);

	return true;

}

//--------------------------------------------------------------------------

bool CameraSettingsWidget::parsePresetString(const QString &str,

											 QString &name,

											 int &xres,

											 int &yres,

											 double &fx,

											 double &fy,

											 QString &xoffset,

											 QString &yoffset,

											 double &ar,

											 bool forCleanup)

{

	int len = str.length();

	int i = len - 1;

	while (i >= 0 && str[i] == ' ')

		i--;

	int j = i;

	//--- A/R

	while (i >= 0 && '0' <= str[i] && str[i] <= '9')

		i--;

	if (i == len - 1 || i < 0)

		return false;

	if (str[i] == '/' || str[i] == '.') {

		i--;

		int ii = i;

		while (i >= 0 && '0' <= str[i] && str[i] <= '9')

			i--;

		if (i == ii)

			return false;

	}

	ar = aspectRatioStringToValue(str.mid(i + 1, j - i));

	//--- cleanup camera offsets

	if (forCleanup) {

		// yoffset

		while (i >= 0 && str[i] == ' ')

			i--;

		if (i < 0 || str[i] != ',')

			return false;

		i--;

		while (i >= 0 && str[i] == ' ')

			i--;

		j = i;

		while (i >= 0 && str[i] != ',')

			i--;

		if (i < 0)

			return false;

		i++;

		yoffset = str.mid(i + 1, j - i);

		// xoffset

		while (i >= 0 && str[i] == ' ')

			i--;

		if (i < 0 || str[i] != ',')

			return false;

		i--;

		while (i >= 0 && str[i] == ' ')

			i--;

		j = i;

		while (i >= 0 && str[i] != ',')

			i--;

		if (i < 0)

			return false;

		i++;

		xoffset = str.mid(i + 1, j - i);

	}

	//--- camera size

	// fy

	while (i >= 0 && str[i] == ' ')

		i--;

	if (i < 0 || str[i] != ',')

		return false;

	i--;

	while (i >= 0 && str[i] == ' ')

		i--;

	j = i;

	while (i >= 0 && (('0' <= str[i] && str[i] <= '9') || str[i] == '.'))

		i--;

	if (j == i || i < 0)

		return false;

	fy = str.mid(i + 1, j - i).toDouble();

	// fx

	while (i >= 0 && str[i] == ' ')

		i--;

	if (i < 0 || str[i] != 'x')

		return false;

	i--;

	while (i >= 0 && str[i] == ' ')

		i--;

	j = i;

	while (i >= 0 && (('0' <= str[i] && str[i] <= '9') || str[i] == '.'))

		i--;

	if (j == i || i < 0)

		return false;

	fx = str.mid(i + 1, j - i).toDouble();

	// yres

	while (i >= 0 && str[i] == ' ')

		i--;

	if (i < 0 || str[i] != ',')

		return false;

	i--;

	while (i >= 0 && str[i] == ' ')

		i--;

	j = i;

	while (i >= 0 && '0' <= str[i] && str[i] <= '9')

		i--;

	if (j == i || i < 0)

		return false;

	yres = str.mid(i + 1, j - i).toInt();

	// xres

	while (i >= 0 && str[i] == ' ')

		i--;

	if (i < 0 || str[i] != 'x')

		return false;

	i--;

	while (i >= 0 && str[i] == ' ')

		i--;

	j = i;

	while (i >= 0 && '0' <= str[i] && str[i] <= '9')

		i--;

	if (j == i || i < 0)

		return false;

	xres = str.mid(i + 1, j - i).toInt();

	// name

	while (i >= 0 && str[i] == ' ')

		i--;

	if (i >= 0 && str[i] == ',')

		i--;

	if (i < 0)

		return false;

	i++;

	int k = 0;

	while (k < i && str[k] == ' ')

		k++;

	if (k == i)

		return false;

	/*--- 1文字のカメラ名にも対応するため ---*/

	name = str.mid(k, i - k);

	return true;

}

//--------------------------------------------------------------------------

void CameraSettingsWidget::setPresetListFile(const TFilePath &fp)

{

	m_presetListFile = QString::fromStdWString(fp.getWideString());

	loadPresetList();

}

bool CameraSettingsWidget::eventFilter(QObject *obj, QEvent *e)

{

	if (e->type() == QEvent::FocusIn) {

		if (m_xPrev->isChecked() && obj == m_lxFld) // x-prev, fld=lx

			m_yPrev->setChecked(true);

		else if (m_yPrev->isChecked() && obj == m_lyFld) // y-prev, fld=ly

			m_xPrev->setChecked(true);

		else if (m_arPrev->isChecked() && obj == m_arFld) // ar-prev, fld=ar

			m_xPrev->setChecked(true);

		if (m_inchPrev->isChecked() && (obj == m_lxFld || obj == m_lyFld || obj == m_arFld)) // inchPrev, fld = lx|ly|ar

			m_dotPrev->setChecked(true);

		else if (m_dotPrev->isChecked() && (obj == m_xResFld || obj == m_yResFld)) // dotPrev, fld = xres|yres

			m_inchPrev->setChecked(true);

	}

	return QObject::eventFilter(obj, e);

}

void CameraSettingsWidget::setCurrentLevel(TXshLevel *xshLevel)

{

	TXshSimpleLevel *sl = xshLevel ? xshLevel->getSimpleLevel() : 0;

	if (sl && sl->getType() == PLI_XSHLEVEL)

		sl = 0;

	if (sl == m_currentLevel)

		return;

	if (sl)

		sl->addRef();

	if (m_currentLevel)

		m_currentLevel->release();

	m_currentLevel = sl;

	m_useLevelSettingsBtn->setEnabled(m_currentLevel != 0);

}

void CameraSettingsWidget::useLevelSettings()

{

	TXshSimpleLevel *sl = m_currentLevel;

	if (!sl)

		return;

	// Build dpi

	TPointD dpi = sl->getDpi(TFrameId::NO_FRAME, 0);

	// Build physical size

	TDimensionD size(0, 0);

	TDimension res = sl->getResolution();

	if (res.lx <= 0 || res.ly <= 0 || dpi.x <= 0 || dpi.y <= 0)

		return;

	size.lx = res.lx / dpi.x;

	size.ly = res.ly / dpi.y;

	TCamera camera;

	getFields(&camera);

	camera.setSize(size);

	camera.setRes(res);

	setFields(&camera);

	emit levelSettingsUsed();

	emit changed();

}

void CameraSettingsWidget::setFields(const TCamera *camera)

{

	TDimensionD sz = camera->getSize();

	TDimension res = camera->getRes();

	m_lxFld->setValue(sz.lx);

	m_lyFld->setValue(sz.ly);

	m_xResFld->setValue(res.lx);

	m_yResFld->setValue(res.ly);

	setArFld(sz.lx / sz.ly);

	m_xDpiFld->setValue(res.lx / sz.lx);

	m_yDpiFld->setValue(res.ly / sz.ly);

	updatePresetListOm();

}

void CameraSettingsWidget::getFields(TCamera *camera)

{

	camera->setSize(getSize());

	camera->setRes(getRes());

}

TDimensionD CameraSettingsWidget::getSize() const

{

	double lx = m_lxFld->getValue();

	double ly = m_lyFld->getValue();

	return TDimensionD(lx, ly);

}

TDimension CameraSettingsWidget::getRes() const

{

	int xRes = (int)(m_xResFld->getValue());

	int yRes = (int)(m_yResFld->getValue());

	return TDimension(xRes, yRes);

}

void CameraSettingsWidget::updatePresetListOm()

{

	if (m_presetListOm->currentIndex() == 0)

		return;

	bool match = false;

	int xres, yres;

	QString name, arStr;

	double fx, fy;

	QString xoffset, yoffset;

	double ar;

	if (parsePresetString(m_presetListOm->currentText(),

						  name,

						  xres,

						  yres,

						  fx,

						  fy,

						  xoffset,

						  yoffset,

						  ar,

						  m_forCleanup)) {

		double eps = 1.0e-6;

		if (m_forCleanup && m_offsX && m_offsY) {

			match = xres == m_xResFld->getValue() &&

					yres == m_yResFld->getValue() &&

					fx == m_lxFld->getValue() &&

					fy == m_lyFld->getValue() &&

					xoffset == m_offsX->text() &&

					yoffset == m_offsY->text();

		} else {

			match = xres == m_xResFld->getValue() &&

					yres == m_yResFld->getValue() &&

					fx == m_lxFld->getValue() &&

					fy == m_lyFld->getValue();

		}

	}

	if (!match)

		m_presetListOm->setCurrentIndex(0);

}

// ly,ar => lx

void CameraSettingsWidget::hComputeLx()

{

	m_lxFld->setValue(m_lyFld->getValue() * m_arValue);

}

// lx,ar => ly

void CameraSettingsWidget::hComputeLy()

{

	if (m_arValue == 0.0)

		return; // non dovrebbe mai succedere

	m_lyFld->setValue(m_lxFld->getValue() / m_arValue);

}

// lx,ly => ar

void CameraSettingsWidget::computeAr()

{

	if (m_lyFld->getValue() == 0.0)

		return; // non dovrebbe mai succedere

	setArFld(m_lxFld->getValue() / m_lyFld->getValue());

}

// xres,xdpi => lx

void CameraSettingsWidget::vComputeLx()

{

	if (m_xDpiFld->getValue() == 0.0)

		return; // non dovrebbe mai succedere

	m_lxFld->setValue(m_xResFld->getValue() / m_xDpiFld->getValue());

}

// yres,ydpi => ly

void CameraSettingsWidget::vComputeLy()

{

	if (m_yDpiFld->getValue() == 0.0)

		return; // non dovrebbe mai succedere

	m_lyFld->setValue(m_yResFld->getValue() / m_yDpiFld->getValue());

}

// lx,xdpi => xres

void CameraSettingsWidget::computeXRes()

{

	m_xResFld->setValue(tround(m_lxFld->getValue() * m_xDpiFld->getValue()));

}

// ly,ydpi => yres

void CameraSettingsWidget::computeYRes()

{

	m_yResFld->setValue(tround(m_lyFld->getValue() * m_yDpiFld->getValue()));

}

// lx,xres => xdpi

void CameraSettingsWidget::computeXDpi()

{

	if (m_lxFld->getValue() == 0.0)

		return; // non dovrebbe mai succedere

	m_xDpiFld->setValue(m_xResFld->getValue() / m_lxFld->getValue());

}

// ly,yres => ydpi

void CameraSettingsWidget::computeYDpi()

{

	if (m_lyFld->getValue() == 0.0)

		return; // non dovrebbe mai succedere

	m_yDpiFld->setValue(m_yResFld->getValue() / m_lyFld->getValue());

}

// set A/R field, assign m_arValue and compute a nice string representation for the value (e.g. "4/3" instead of 1.3333333)

void CameraSettingsWidget::setArFld(double ar)

{

	m_arValue = ar;

	/*---ピクセルサイズのW/Hの値に近かったら"W/H"と表示する---*/

	m_arFld->setValue(ar, (int)m_xResFld->getValue(), (int)m_yResFld->getValue());

}

// compute res or dpi according to the prevalence

void CameraSettingsWidget::computeResOrDpi()

{

	computeXRes();

	computeYRes();

}

void CameraSettingsWidget::onLxChanged()

{

	assert(!m_inchPrev->isChecked());

	//assert(!(m_fspChk->isChecked() && m_yPrev->isChecked() && m_dotPrev->isChecked()));

	if (m_yPrev->isChecked())

		computeAr();

	else

		hComputeLy();

	computeResOrDpi();

	updatePresetListOm();

	emit changed();

}

void CameraSettingsWidget::onLyChanged()

{

	assert(!m_inchPrev->isChecked());

	//assert(!(m_fspChk->isChecked() && m_xPrev->isChecked() && m_dotPrev->isChecked()));

	if (m_xPrev->isChecked())

		computeAr();

	else

		hComputeLx();

	computeResOrDpi();

	updatePresetListOm();

	emit changed();

}

void CameraSettingsWidget::onArChanged()

{

	m_arValue = aspectRatioStringToValue(m_arFld->text());

	if (m_xPrev->isChecked())

		hComputeLy();

	else

		hComputeLx();

	computeResOrDpi();

	updatePresetListOm();

	emit changed();

}

void CameraSettingsWidget::onXResChanged()

{

	vComputeLx();

	if (m_yPrev->isChecked())

		computeAr();

	else {

		hComputeLy();

		computeYRes();

	}

	updatePresetListOm();

	emit changed();

}

void CameraSettingsWidget::onYResChanged()

{

	vComputeLy();

	if (m_xPrev->isChecked())

		computeAr();

	else {

		hComputeLx();

		computeXRes();

	}

	updatePresetListOm();

	emit changed();

}

void CameraSettingsWidget::onXDpiChanged()

{

	if (m_fspChk->isChecked())

		m_yDpiFld->setValue(m_xDpiFld->getValue());

	if (m_dotPrev->isChecked()) {

		vComputeLx();

		if (m_arPrev->isChecked()) {

			hComputeLy();

			if (!m_fspChk->isChecked())

				computeYDpi();

		} else

			computeAr();

	} else {

		computeXRes();

		computeYRes();

	}

	updatePresetListOm();

	emit changed();