/*
    Object Viewer Qt
    Copyright (C) 2010 Dzmitry Kamiahin <dnk-88@tut.by>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "stdpch.h"
#include "attrib_widget.h"

// Qt includes
#include <QtGui/QInputDialog>

// NeL includes
#include <nel/3d/ps_attrib_maker.h>
#include <nel/3d/ps_float.h>
#include <nel/3d/ps_int.h>
#include <nel/3d/ps_color.h>
#include <nel/3d/ps_plane_basis.h>
#include <nel/3d/ps_plane_basis_maker.h>

// Projects includes
#include "value_blender_dialog.h"
#include "value_gradient_dialog.h"
#include "bin_op_dialog.h"
#include "curve_dialog.h"
#include "value_from_emitter_dialog.h"
#include "spinner_dialog.h"
#include "follow_path_dialog.h"

namespace NLQT
{

CAttribWidget::CAttribWidget(QWidget *parent)
	: QGroupBox(parent),
	  _SrcInputEnabled(true),
	  _EnableConstantValue(true),
	  _DisableMemoryScheme(false),
	  _NbCycleEnabled(true),
	  _Node(NULL),
	  _SchemeWidget(NULL)
{
	_ui.setupUi(this);
	_ui.constRangeUIntWidget->hide();
	_ui.constRangeFloatWidget->hide();
	_ui.constAttribPlaneWidget->hide();
	_ui.constRangeIntWidget->hide();
	_ui.constRGBAWidget->hide();
	_ui.schemeWidget->hide();

	_ui.inMultiplierWidget->setRange(0.1f, 10.1f);
	_ui.inMultiplierWidget->enableLowerBound(0, true);;
	_ui.inMultiplierWidget->setWrapper(&_NbCyclesWrapper);
	_NbCyclesWrapper.widget = this;
}

CAttribWidget::~CAttribWidget()
{
}

void CAttribWidget::setEnabledConstantValue(bool enableConstantValue)
{
	_EnableConstantValue = enableConstantValue;
}

void CAttribWidget::init()
{
	connect(_ui.editPushButton, SIGNAL(clicked()), this, SLOT(clickedEdit()));
	connect(_ui.clampCheckBox, SIGNAL(toggled(bool)), this, SLOT(setClamp(bool)));
	connect(_ui.schemeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(changeCurrentScheme(int)));
	connect(_ui.srcComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(setCurrentSrc(int)));
	connect(_ui.userParamPushButton, SIGNAL(clicked()), this, SLOT(setUserIndex()));
	connect(_ui.comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(changeUseScheme(int)));
}

void CAttribWidget::updateUi()
{
	if  (!_EnableConstantValue)
		_ui.comboBox->hide();
	else
		_ui.comboBox->show();

	if (useScheme())
	{
		if (_ui.comboBox->currentIndex() == 1)
			schemeValueUpdate();
		else
			_ui.comboBox->setCurrentIndex(1);
	}
	else
	{

		nlassert(_EnableConstantValue);
		if (_ui.comboBox->currentIndex() == 0)
			cstValueUpdate();
		else
			_ui.comboBox->setCurrentIndex(0);
	}
}

void CAttribWidget::clickedEdit()
{
	QDialog *dialog = editScheme();
	if (dialog != NULL)
	{
		dialog->setModal(true);
		dialog->show();
		dialog->exec();
		delete dialog;
	}
}

void CAttribWidget::setClamp(bool state)
{
	// avoid performance warning
	if (state != isSchemeClamped())
		clampScheme(state);
}

void CAttribWidget::changeCurrentScheme(int index)
{
	if (getCurrentScheme() != index)
		setCurrentScheme(uint(index));
	schemeValueUpdate();
}

void CAttribWidget::setCurrentSrc(int index)
{
	NL3D::CPSInputType it;
	it.InputType = (NL3D::CPSInputType::TInputType) index;
	if (it.InputType != getSchemeInput().InputType)
	{
		if (it.InputType == NL3D::CPSInputType::attrUserParam)
		{
			it.UserParamNum = 0;
		}
		setSchemeInput(it);
	}
	inputValueUpdate();
}

void CAttribWidget::setUserIndex()
{
	bool ok;
	int i = QInputDialog::getInt(this, tr("Set user param"), tr(""), getSchemeInput().UserParamNum + 1, 1, 4, 1, &ok);
	if (ok)
	{
		NL3D::CPSInputType it =  getSchemeInput();
		it.UserParamNum = i - 1;
		setSchemeInput(it);
	}
	inputValueUpdate();
}

void CAttribWidget::changeUseScheme(int index)
{
	if (index == 0)
	{
		if (useScheme())
			resetCstValue(); // change constant
		cstValueUpdate(); // update ui
	}
	else
	{
		if (useScheme())
			changeCurrentScheme(getCurrentScheme()); // update ui
		else
			changeCurrentScheme(0); // change scheme
	}
}

void CAttribWidget::inputValueUpdate(void)
{
	if (useScheme() && getSchemeInput().InputType == NL3D::CPSInputType::attrUserParam)
	{
		//_ui.userParamPushButton->setText(tr("User param: %1").arg(getSchemeInput().UserParamNum + 1));
		_ui.userParamPushButton->setEnabled(true);
	}
	else
	{
		//_ui.userParamPushButton->setText(tr("User param:"));
		_ui.userParamPushButton->setEnabled(false);
	}
}

void CAttribWidget::schemeValueUpdate()
{
	if (!useScheme()) return;

	_ui.constRangeUIntWidget->hide();
	_ui.constRangeFloatWidget->hide();
	_ui.constAttribPlaneWidget->hide();
	_ui.constRangeIntWidget->hide();
	_ui.constRGBAWidget->hide();

	_ui.schemeWidget->show();

	sint k = getCurrentScheme();

	if (k == -1) // unknow scheme ...
	{
		_ui.schemeComboBox->setCurrentIndex(k);
		k = 0;
	}

	if (k != _ui.schemeComboBox->currentIndex())
		_ui.schemeComboBox->setCurrentIndex(k);

	if (hasSchemeCustomInput() && _SrcInputEnabled)
	{
		_ui.srcLabel->setEnabled(true);
		_ui.srcComboBox->setEnabled(true);
		_ui.srcComboBox->setCurrentIndex(int(getSchemeInput().InputType));

		_ui.clampCheckBox->setEnabled(isClampingSupported());
		_ui.inMultiplierWidget->setEnabled(isClampingSupported());
		_ui.inputLabel->setEnabled(isClampingSupported());
	}
	else
	{
		_ui.srcLabel->setEnabled(false);
		_ui.srcComboBox->setEnabled(false);
		inputValueUpdate();

		_ui.clampCheckBox->setEnabled(false);
		_ui.inMultiplierWidget->setEnabled(false);
		_ui.inputLabel->setEnabled(false);
	}

	if (_NbCycleEnabled)
	{
		_ui.inMultiplierWidget->updateUi();
		_ui.inMultiplierWidget->show();
		_ui.inputLabel->show();
		_ui.inMultiplierWidget->setEnabled(true);
		_ui.clampCheckBox->show();
	}
	else
	{
		_ui.inputLabel->hide();
		_ui.inMultiplierWidget->hide();
		_ui.clampCheckBox->hide();
	}

	if (isClampingSupported())
		_ui.clampCheckBox->setChecked(isSchemeClamped());
}

void CAttribWidget::enableMemoryScheme(bool enabled)
{
	_DisableMemoryScheme = !enabled;
	if (!enabled)
	{
		_ui.schemeComboBox->removeItem(_ui.schemeComboBox->count() - 1);
		_ui.schemeComboBox->removeItem(_ui.schemeComboBox->count() - 1);
	}
}

CAttribFloatWidget::CAttribFloatWidget(QWidget *parent)
	: CAttribWidgetT<float>(parent)
{
	_ui.schemeComboBox->addItem(tr("value blender"));
	_ui.schemeComboBox->addItem(tr("values gradient"));
	_ui.schemeComboBox->addItem(tr("curve"));
	_ui.schemeComboBox->addItem(tr("value computed from emitter"));
	_ui.schemeComboBox->addItem(tr("binary operator"));
}

CAttribFloatWidget::~CAttribFloatWidget()
{
}

void CAttribFloatWidget::setRange(float minValue, float maxValue)
{
	_MinRange = minValue;
	_MaxRange = maxValue;
	_ui.constRangeFloatWidget->setRange(_MinRange, _MaxRange);
}

void CAttribFloatWidget::setWrapper(IPSWrapper<float> *wrapper)
{
	nlassert(wrapper);
	_Wrapper = wrapper;
	_ui.constRangeFloatWidget->setWrapper(_Wrapper);
}

QDialog *CAttribFloatWidget::editScheme(void)
{
	NL3D::CPSAttribMaker<float> *scheme = _SchemeWrapper->getScheme();

	if (dynamic_cast<NL3D::CPSFloatBlender *>(scheme))
	{
		CFloatBlenderDialogClient *myInterface = new CFloatBlenderDialogClient();
		myInterface->MinRange = _MinRange;
		myInterface->MaxRange = _MaxRange;
		myInterface->SchemeFunc = & ((NL3D::CPSValueBlenderSample<float, 64> *) scheme)->_F;
		CValueBlenderDialog *vb = new CValueBlenderDialog(myInterface, _Node, true, this);
		return vb;
	}
	if (dynamic_cast<NL3D::CPSFloatGradient *>(scheme))
	{
		CFloatGradientWrapper *wrapper = new CFloatGradientWrapper;
		wrapper->MinRange = _MinRange;
		wrapper->MaxRange = _MaxRange;
		wrapper->Scheme = &(((NL3D::CPSFloatGradient *) (_SchemeWrapper->getScheme()) )->_F);
		CGradientDialog *gd = new CGradientDialog(_Node, wrapper, true, true, 2, this);
		wrapper->DefaultValue = 0.f;
		return gd;
	}
	if (dynamic_cast<NL3D::CPSFloatMemory *>(scheme))
	{
		CAttribFloatWidget *adf = new CAttribFloatWidget();
		adf->setRange(_MinRange, _MaxRange);
		CValueFromEmitterDialogT<float> *vfe = new CValueFromEmitterDialogT<float>( (NL3D::CPSFloatMemory *)(scheme),
				adf,
				this);
		vfe->init();
		adf->setWorkspaceNode(_Node);
		adf->updateUi();
		return vfe;
	}
	if (dynamic_cast<NL3D::CPSFloatBinOp *>(scheme))
	{
		CAttribFloatWidget *ad[2] = { NULL, NULL};
		for (uint k = 0; k <2; ++k)
		{
			ad[k] = new CAttribFloatWidget();
			ad[k]->setRange(_MinRange, _MaxRange);
		}
		CBinOpDialogT<float> *bod = new CBinOpDialogT<float>( (NL3D::CPSFloatBinOp *)(scheme),
				(CAttribWidgetT<float> **) ad,
				this);
		bod->init();
		for (uint k = 0; k <2; ++k)
		{
			ad[k]->setWorkspaceNode(_Node);
			ad[k]->updateUi();
		}
		return bod;
	}
	if (dynamic_cast<NL3D::CPSFloatCurve *>(scheme))
	{
		CurveEditDialog *curve = new CurveEditDialog(&(dynamic_cast<NL3D::CPSFloatCurve *>(scheme)->_F), _Node, this);
		return curve;
	}
	return NULL;
}

void CAttribFloatWidget::setCurrentScheme(uint index)
{
	nlassert(index < 5);
	NL3D::CPSAttribMaker<float> *scheme = NULL;

	switch (index)
	{
	case 0:
		scheme = new NL3D::CPSFloatBlender(_MinRange, _MaxRange);
		break;
	case 1:
	{
		static const float values[2] = { 0.1f, 1.f };
		scheme = new NL3D::CPSFloatGradient(values, 2, 16, 1.f);
	}
	break;
	case 2:
	{
		NL3D::CPSFloatCurve *curve = new NL3D::CPSFloatCurve;
		curve->_F.setNumSamples(128);
		curve->_F.addControlPoint(NL3D::CPSFloatCurveFunctor::CCtrlPoint(0, 0.5f));
		curve->_F.addControlPoint(NL3D::CPSFloatCurveFunctor::CCtrlPoint(1, 0.5f));
		scheme = curve;
	}
	break;
	case 3:
		scheme = new NL3D::CPSFloatMemory;
		((NL3D::CPSAttribMakerMemory<float> *) scheme)->setScheme(new NL3D::CPSFloatBlender(_MinRange, _MaxRange));
		break;
	case 4 :
		scheme = new NL3D::CPSFloatBinOp;
		((NL3D::CPSFloatBinOp *) scheme)->setArg(0, new NL3D::CPSFloatBlender);
		((NL3D::CPSFloatBinOp *) scheme)->setArg(1, new NL3D::CPSFloatBlender);
		break;
	default:
		break;
	}

	if (scheme)
	{
		_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
	}
}

sint CAttribFloatWidget::getCurrentScheme(void) const
{
	const NL3D::CPSAttribMaker<float> *scheme = _SchemeWrapper->getScheme();

	if (dynamic_cast<const NL3D::CPSFloatBlender *>(scheme))
		return 0;
	if (dynamic_cast<const NL3D::CPSFloatGradient *>(scheme))
		return 1;
	if (dynamic_cast<const NL3D::CPSFloatCurve *>(scheme))
		return 2;
	if (dynamic_cast<const NL3D::CPSFloatMemory *>(scheme))
		return 3;
	if (dynamic_cast<const NL3D::CPSFloatBinOp *>(scheme))
		return 4;

	return -1;
}

void CAttribFloatWidget::cstValueUpdate()
{
	_ui.schemeWidget->hide();
	_ui.inMultiplierWidget->setEnabled(false);
	_ui.clampCheckBox->setEnabled(false);
	_ui.inputLabel->setEnabled(false);
	_ui.constRangeFloatWidget->show();
	_ui.constRangeFloatWidget->updateUi();
}

CAttribUIntWidget::CAttribUIntWidget(QWidget *parent)
	: CAttribWidgetT<uint32>(parent)
{
	_ui.schemeComboBox->addItem(tr("value blender"));
	_ui.schemeComboBox->addItem(tr("values gradient"));
	_ui.schemeComboBox->addItem(tr("value computed from emitter"));
	_ui.schemeComboBox->addItem(tr("binary operator"));
}

CAttribUIntWidget::~CAttribUIntWidget()
{
}

void CAttribUIntWidget::setRange(uint32 minValue, uint32 maxValue)
{
	_MinRange = minValue;
	_MaxRange = maxValue;
	_ui.constRangeUIntWidget->setRange(_MinRange, _MaxRange);
}

void CAttribUIntWidget::setWrapper(IPSWrapper<uint32> *wrapper)
{
	nlassert(wrapper);
	_Wrapper = wrapper;
	_ui.constRangeUIntWidget->setWrapper(_Wrapper);
}

QDialog *CAttribUIntWidget::editScheme(void)
{
	const NL3D::CPSAttribMaker<uint32> *scheme = _SchemeWrapper->getScheme();

	if (dynamic_cast<const NL3D::CPSUIntBlender *>(scheme))
	{
		CUIntBlenderDialogClient *myInterface = new CUIntBlenderDialogClient();
		myInterface->MinRange = _MinRange;
		myInterface->MaxRange = _MaxRange;
		myInterface->SchemeFunc = & ((NL3D::CPSValueBlenderSample<uint32, 64> *) scheme)->_F;
		CValueBlenderDialog *vb = new CValueBlenderDialog(myInterface, _Node, true, this);
		return vb;
	}
	if (dynamic_cast<const NL3D::CPSUIntGradient *>(scheme))
	{
		CUIntGradientWrapper *wrapper = new CUIntGradientWrapper;
		wrapper->MinRange = _MinRange;
		wrapper->MaxRange = _MaxRange;
		wrapper->Scheme = &(((NL3D::CPSUIntGradient *) (_SchemeWrapper->getScheme()) )->_F);
		CGradientDialog *gd = new CGradientDialog(_Node, wrapper, true, true, 2, this);
		wrapper->DefaultValue = 0;
		return gd;

	}
	if (dynamic_cast<const NL3D::CPSUIntMemory *>(scheme))
	{
		CAttribUIntWidget *adu = new CAttribUIntWidget();
		adu->setRange(_MinRange, _MaxRange);
		CValueFromEmitterDialogT<uint32> *vfe = new CValueFromEmitterDialogT<uint32>( (NL3D::CPSUIntMemory *)(scheme),
				adu,
				this);
		vfe->init();
		adu->setWorkspaceNode(_Node);
		adu->updateUi();
		return vfe;
	}
	if (dynamic_cast<const NL3D::CPSUIntBinOp *>(scheme))
	{
		CAttribUIntWidget *ad[2] = { NULL, NULL};
		for (uint k = 0; k <2; ++k)
		{
			ad[k] = new CAttribUIntWidget();
			ad[k]->setRange(_MinRange, _MaxRange);
		}
		CBinOpDialogT<uint32> *bod = new CBinOpDialogT<uint32>( (NL3D::CPSUIntBinOp *)(scheme),
				(CAttribWidgetT<uint32> **) ad,
				this);
		bod->init();
		for (uint k = 0; k <2; ++k)
		{
			ad[k]->setWorkspaceNode(_Node);
			ad[k]->updateUi();
		}
		return bod;
	}
	return NULL;
}

void CAttribUIntWidget::setCurrentScheme(uint index)
{
	nlassert(index < 4);
	NL3D::CPSAttribMaker<uint32> *scheme = NULL;

	switch (index)
	{
	case 0 :
		scheme = new NL3D::CPSUIntBlender(_MinRange, _MaxRange);
		break;
	case 1 :
		scheme = new NL3D::CPSUIntGradient;
		break;
	case 2 :
		scheme = new NL3D::CPSUIntMemory;
		((NL3D::CPSAttribMakerMemory<uint32> *) scheme)->setScheme(new NL3D::CPSUIntBlender(_MinRange, _MaxRange) );
		break;
	case 3 :
		scheme = new NL3D::CPSUIntBinOp;
		((NL3D::CPSUIntBinOp *) scheme)->setArg(0, new NL3D::CPSUIntBlender);
		((NL3D::CPSUIntBinOp *) scheme)->setArg(1, new NL3D::CPSUIntBlender);
		break;
	default:
		break;
	}
	if (scheme)
	{
		_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
	}
}

sint CAttribUIntWidget::getCurrentScheme(void) const
{
	const NL3D::CPSAttribMaker<uint32> *scheme = _SchemeWrapper->getScheme();

	if (dynamic_cast<const NL3D::CPSUIntBlender *>(scheme))  return 0;
	if (dynamic_cast<const NL3D::CPSUIntGradient *>(scheme)) return 1;
	if (dynamic_cast<const NL3D::CPSUIntMemory *>(scheme))   return 2;
	if (dynamic_cast<const NL3D::CPSUIntBinOp *>(scheme))	 return 3;
	return -1;
}

void CAttribUIntWidget::cstValueUpdate()
{
	_ui.schemeWidget->hide();
	_ui.inMultiplierWidget->setEnabled(false);
	_ui.clampCheckBox->setEnabled(false);
	_ui.inputLabel->setEnabled(false);
	_ui.constRangeUIntWidget->show();
	_ui.constRangeUIntWidget->updateUi();
}

CAttribIntWidget::CAttribIntWidget(QWidget *parent)
	: CAttribWidgetT<sint32>(parent)
{
	_ui.schemeComboBox->addItem(tr("value exact blender"));
	_ui.schemeComboBox->addItem(tr("values gradient"));
	_ui.schemeComboBox->addItem(tr("value computed from emitter"));
	_ui.schemeComboBox->addItem(tr("binary operator"));
}

CAttribIntWidget::~CAttribIntWidget()
{
}

void CAttribIntWidget::setRange(sint32 minValue, sint32 maxValue)
{
	_MinRange = minValue;
	_MaxRange = maxValue;
	_ui.constRangeIntWidget->setRange(_MinRange, _MaxRange);
}

void CAttribIntWidget::setWrapper(IPSWrapper<sint32> *wrapper)
{
	nlassert(wrapper);
	_Wrapper = wrapper;
	_ui.constRangeIntWidget->setWrapper(_Wrapper);
}

QDialog *CAttribIntWidget::editScheme(void)
{
	const NL3D::CPSAttribMaker<sint32> *scheme = _SchemeWrapper->getScheme();

	if (dynamic_cast<const NL3D::CPSIntBlender *>(scheme))
	{
		CIntBlenderDialogClient *myInterface = new CIntBlenderDialogClient();
		myInterface->MinRange = _MinRange;
		myInterface->MaxRange = _MaxRange;
		myInterface->SchemeFunc = & ((NL3D::CPSValueBlenderSample<sint32, 64> *) scheme)->_F;
		CValueBlenderDialog *vb = new CValueBlenderDialog(myInterface, _Node, true, this);
		return vb;
	}
	if (dynamic_cast<const NL3D::CPSIntGradient *>(scheme))
	{
		CIntGradientWrapper *wrapper = new CIntGradientWrapper;
		wrapper->MinRange = _MinRange;
		wrapper->MaxRange = _MaxRange;
		wrapper->Scheme = &(((NL3D::CPSIntGradient *) (_SchemeWrapper->getScheme()) )->_F);
		CGradientDialog *gd = new CGradientDialog(_Node, wrapper, true, true, 2, this);
		wrapper->DefaultValue = 0;
		return gd;
	}
	if (dynamic_cast<const NL3D::CPSIntMemory *>(scheme))
	{
		CAttribIntWidget *adi = new CAttribIntWidget();
		adi->setRange(_MinRange, _MaxRange);
		CValueFromEmitterDialogT<sint32> *vfe = new CValueFromEmitterDialogT<sint32>((NL3D::CPSIntMemory *) _SchemeWrapper->getScheme(),
				adi, this);
		vfe->init();
		adi->setWorkspaceNode(_Node);
		adi->updateUi();
		return vfe;
	}
	if (dynamic_cast<const NL3D::CPSIntBinOp *>(scheme))
	{
		CAttribIntWidget *ad[2] = { NULL, NULL};
		for (uint k = 0; k <2; ++k)
		{
			ad[k] = new CAttribIntWidget();
			ad[k]->setRange(_MinRange, _MaxRange);
		}
		CBinOpDialogT<sint32> *bod = new CBinOpDialogT<sint32>( (NL3D::CPSIntBinOp *)(scheme),
				(CAttribWidgetT<sint32> **) ad,
				this);
		bod->init();
		for (uint k = 0; k <2; ++k)
		{
			ad[k]->setWorkspaceNode(_Node);
			ad[k]->updateUi();
		}
		return bod;
	}
	return NULL;
}

void CAttribIntWidget::setCurrentScheme(uint index)
{
	nlassert(index < 4);
	NL3D::CPSAttribMaker<sint32> *scheme = NULL;

	switch (index)
	{
	case 0 :
		scheme = new NL3D::CPSIntBlender;
		break;
	case 1 :
		scheme = new NL3D::CPSIntGradient;
		break;
	case 2 :
		scheme = new NL3D::CPSIntMemory;
		((NL3D::CPSAttribMakerMemory<sint32> *) scheme)->setScheme(new NL3D::CPSIntBlender(_MinRange, _MaxRange));
		break;
	case 3 :
		scheme = new NL3D::CPSIntBinOp;
		((NL3D::CPSIntBinOp *) scheme)->setArg(0, new NL3D::CPSIntBlender);
		((NL3D::CPSIntBinOp *) scheme)->setArg(1, new NL3D::CPSIntBlender);
		break;
	default:
		break;
	}
	if (scheme)
	{
		_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
	}
}

sint CAttribIntWidget::getCurrentScheme(void) const
{
	const NL3D::CPSAttribMaker<sint32> *scheme = _SchemeWrapper->getScheme();

	if (dynamic_cast<const NL3D::CPSIntBlender *>(scheme)) return 0;
	if (dynamic_cast<const NL3D::CPSIntGradient *>(scheme)) return 1;
	if (dynamic_cast<const NL3D::CPSIntMemory *>(scheme)) return 2;
	if (dynamic_cast<const NL3D::CPSIntBinOp *>(scheme)) return 3;
	return -1;
}

void CAttribIntWidget::cstValueUpdate()
{
	_ui.schemeWidget->hide();
	_ui.inMultiplierWidget->setEnabled(false);
	_ui.clampCheckBox->setEnabled(false);
	_ui.inputLabel->setEnabled(false);
	_ui.constRangeIntWidget->show();
	//_ui.constRangeIntWidget->updateUi();
}

CAttribRGBAWidget::CAttribRGBAWidget(QWidget *parent)
	: CAttribWidgetT<NLMISC::CRGBA>(parent)
{
	_ui.schemeComboBox->addItem(tr("color sampled blender"));
	_ui.schemeComboBox->addItem(tr("color gradient"));
	_ui.schemeComboBox->addItem(tr("color exact blender"));
	_ui.schemeComboBox->addItem(tr("values computed from emitter"));
	_ui.schemeComboBox->addItem(tr("binary operator"));
}

CAttribRGBAWidget::~CAttribRGBAWidget()
{
}

void CAttribRGBAWidget::setWrapper(IPSWrapper<NLMISC::CRGBA> *wrapper)
{
	nlassert(wrapper);
	_Wrapper = wrapper;
	_ui.constRGBAWidget->setWrapper(_Wrapper);
}

QDialog *CAttribRGBAWidget::editScheme(void)
{
	const NL3D::CPSAttribMaker<NLMISC::CRGBA> *scheme = _SchemeWrapper->getScheme();

	if (dynamic_cast<const NL3D::CPSColorBlender *>(scheme))
	{
		CRGBABlenderDialogClient *myInterface = new CRGBABlenderDialogClient();
		myInterface->SchemeFunc = & ((NL3D::CPSValueBlenderSample<NLMISC::CRGBA, 64> *) scheme)->_F;
		CValueBlenderDialog *vb = new CValueBlenderDialog(myInterface, _Node, true, this);
		return vb;
	}
	if (dynamic_cast<const NL3D::CPSColorGradient *>(scheme))
	{
		CColorGradientWrapper *wrapper = new CColorGradientWrapper;
		wrapper->Scheme = &(((NL3D::CPSColorGradient *) (_SchemeWrapper->getScheme()) )->_F);
		CGradientDialog *gd = new CGradientDialog(_Node, wrapper, true, true, 2, this);
		wrapper->DefaultValue = NLMISC::CRGBA::White;
		return gd;
	}
	if (dynamic_cast<const NL3D::CPSColorBlenderExact *>(scheme))
	{
		return NULL;
	}
	if (dynamic_cast<const NL3D::CPSColorMemory *>(scheme))
	{
		CAttribRGBAWidget *ad = new CAttribRGBAWidget();
		CValueFromEmitterDialogT<NLMISC::CRGBA> *vfe = new CValueFromEmitterDialogT<NLMISC::CRGBA>( (NL3D::CPSColorMemory *)(scheme),
				ad,
				this);
		vfe->init();
		ad->setWorkspaceNode(_Node);
		ad->updateUi();
		return vfe;
	}
	if (dynamic_cast<const NL3D::CPSColorBinOp *>(scheme))
	{
		CAttribRGBAWidget *ad[2] = { NULL, NULL};
		for (uint k = 0; k <2; ++k)
		{
			ad[k] = new CAttribRGBAWidget();
		}
		CBinOpDialogT<NLMISC::CRGBA> *bod = new CBinOpDialogT<NLMISC::CRGBA>( (NL3D::CPSColorBinOp *)(scheme),
				(CAttribWidgetT<NLMISC::CRGBA> **) ad,
				this);
		bod->init();
		for (uint k = 0; k <2; ++k)
		{
			ad[k]->setWorkspaceNode(_Node);
			ad[k]->updateUi();
		}
		return bod;
	}
	return NULL;
}

void CAttribRGBAWidget::setCurrentScheme(uint index)
{
	nlassert(index < 5);
	NL3D::CPSAttribMaker<NLMISC::CRGBA> *scheme = NULL;

	switch (index)
	{
	case 0 :
		scheme = new NL3D::CPSColorBlender;
		break;
	case 1 :
		scheme = new NL3D::CPSColorGradient(NL3D::CPSColorGradient::_DefaultGradient, 2, 16, 1.f);
		break;
	case 2 :
		scheme = new NL3D::CPSColorBlenderExact;
		break;
	case 3 :
		scheme = new NL3D::CPSColorMemory;
		((NL3D::CPSAttribMakerMemory<NLMISC::CRGBA> *) scheme)->setScheme(new NL3D::CPSColorBlender);
		break;
	case 4 :
		scheme = new NL3D::CPSColorBinOp;
		((NL3D::CPSColorBinOp *) scheme)->setArg(0, new NL3D::CPSColorBlender);
		((NL3D::CPSColorBinOp *) scheme)->setArg(1, new NL3D::CPSColorBlender);
		break;
	default:
		break;
	}
	if (scheme)
	{
		_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
	}
}

sint CAttribRGBAWidget::getCurrentScheme(void) const
{
	const NL3D::CPSAttribMaker<NLMISC::CRGBA> *scheme = _SchemeWrapper->getScheme();

	if (dynamic_cast<const NL3D::CPSColorBlender *>(scheme)) return 0;
	if (dynamic_cast<const NL3D::CPSColorGradient *>(scheme)) return 1;
	if (dynamic_cast<const NL3D::CPSColorBlenderExact *>(scheme)) return 2;
	if (dynamic_cast<const NL3D::CPSColorMemory *>(scheme)) return 3;
	if (dynamic_cast<const NL3D::CPSColorBinOp *>(scheme)) return 4;
	return -1;
}

void CAttribRGBAWidget::cstValueUpdate()
{
	_ui.schemeWidget->hide();
	_ui.inMultiplierWidget->setEnabled(false);
	_ui.clampCheckBox->setEnabled(false);
	_ui.inputLabel->setEnabled(false);
	_ui.constRGBAWidget->show();
	_ui.constRGBAWidget->updateUi();
}

CAttribPlaneBasisWidget::CAttribPlaneBasisWidget(QWidget *parent)
	: CAttribWidgetT<NL3D::CPlaneBasis>(parent)
{
	_ui.schemeComboBox->addItem(tr("basis gradient"));
	_ui.schemeComboBox->addItem(tr("follow path"));
	_ui.schemeComboBox->addItem(tr("spinner"));
	_ui.schemeComboBox->addItem(tr("values computed from emitter"));
	_ui.schemeComboBox->addItem(tr("binary operator"));
}

CAttribPlaneBasisWidget::~CAttribPlaneBasisWidget()
{
}

void CAttribPlaneBasisWidget::setWrapper(IPSWrapper<NL3D::CPlaneBasis> *wrapper)
{
	nlassert(wrapper);
	_Wrapper = wrapper;
	_ui.constAttribPlaneWidget->setWrapper(_Wrapper);
}

QDialog *CAttribPlaneBasisWidget::editScheme(void)
{
	NL3D::CPSAttribMaker<NL3D::CPlaneBasis> *scheme = _SchemeWrapper->getScheme();
	if (dynamic_cast<NL3D::CPSPlaneBasisGradient *>(scheme))
	{
		CPlaneBasisGradientWrapper *wrapper = new CPlaneBasisGradientWrapper;
		wrapper->Scheme = &(((NL3D::CPSPlaneBasisGradient *) (_SchemeWrapper->getScheme()) )->_F);
		CGradientDialog *gd = new CGradientDialog(_Node, wrapper, true, true, 2, this);
		wrapper->DefaultValue = NL3D::CPlaneBasis(NLMISC::CVector::K);
		return gd;
	}
	if (dynamic_cast<NL3D::CPSPlaneBasisFollowSpeed *>(scheme))
	{
		CFollowPathDialog *dialog = new CFollowPathDialog(dynamic_cast<NL3D::CPSPlaneBasisFollowSpeed *>(scheme), _Node, this);
		return dialog;
	}
	if (dynamic_cast<NL3D::CPSPlaneBasisMemory *>(scheme))
	{
		CAttribPlaneBasisWidget *ad = new CAttribPlaneBasisWidget();
		CValueFromEmitterDialogT<NL3D::CPlaneBasis> *vfe = new CValueFromEmitterDialogT<NL3D::CPlaneBasis>
		( (NL3D::CPSPlaneBasisMemory *)(scheme),
		  ad, this);
		vfe->init();
		ad->setWorkspaceNode(_Node);
		ad->updateUi();
		return vfe;
	}
	if (dynamic_cast<NL3D::CPSPlaneBasisBinOp *>(scheme))
	{
		CAttribPlaneBasisWidget *ad[2] = { NULL, NULL};
		for (uint k = 0; k <2; ++k)
		{
			ad[k] = new CAttribPlaneBasisWidget();
		}
		CBinOpDialogT<NL3D::CPlaneBasis> *bod = new CBinOpDialogT<NL3D::CPlaneBasis>( (NL3D::CPSPlaneBasisBinOp *)(scheme),
				(CAttribWidgetT<NL3D::CPlaneBasis> **) ad,
				this);
		bod->init();
		for (uint k = 0; k <2; ++k)
		{
			ad[k]->setWorkspaceNode(_Node);
			ad[k]->updateUi();
		}
		return bod;
	}
	if (dynamic_cast<NL3D::CPSBasisSpinner *>(scheme))
	{
		CSpinnerDialog *dialog = new CSpinnerDialog(dynamic_cast<NL3D::CPSBasisSpinner *>(scheme), _Node, this);
		return dialog;
	}
	return NULL;
}

void CAttribPlaneBasisWidget::setCurrentScheme(uint index)
{
	nlassert(index < 5);
	NL3D::CPSAttribMaker<NL3D::CPlaneBasis> *scheme = NULL;

	switch (index)
	{
	case 0:
		scheme = new NL3D::CPSPlaneBasisGradient;
		break;
	case 1:
		scheme = new NL3D::CPSPlaneBasisFollowSpeed;
		break;
	case 2:
		scheme = new NL3D::CPSBasisSpinner;
		static_cast<NL3D::CPSBasisSpinner *>(scheme)->_F.setNumSamples(16);
		break;
	case 3:
		scheme = new NL3D::CPSPlaneBasisMemory;
		((NL3D::CPSAttribMakerMemory<NL3D::CPlaneBasis> *) scheme)->setScheme(new NL3D::CPSPlaneBasisFollowSpeed);
		if (_Node)
		{
			_Node->setModified(true);
		}
		break;
	case 4 :
		scheme = new NL3D::CPSPlaneBasisBinOp;
		((NL3D::CPSPlaneBasisBinOp *) scheme)->setArg(0, new NL3D::CPSPlaneBasisFollowSpeed);
		((NL3D::CPSPlaneBasisBinOp *) scheme)->setArg(1, new NL3D::CPSPlaneBasisFollowSpeed);
		break;
	default:
		break;
	}

	if (scheme)
	{
		_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
	}
}

sint CAttribPlaneBasisWidget::getCurrentScheme(void) const
{
	const NL3D::CPSAttribMaker<NL3D::CPlaneBasis> *scheme = _SchemeWrapper->getScheme();

	if (dynamic_cast<const NL3D::CPSPlaneBasisGradient *>(scheme)) return 0;
	if (dynamic_cast<const NL3D::CPSPlaneBasisFollowSpeed *>(scheme)) return 1;
	if (dynamic_cast<const NL3D::CPSBasisSpinner *>(scheme)) return 2;
	if (dynamic_cast<const NL3D::CPSPlaneBasisMemory *>(scheme)) return 3;
	if (dynamic_cast<const NL3D::CPSPlaneBasisBinOp *>(scheme)) return 4;

	return -1;
}

void CAttribPlaneBasisWidget::cstValueUpdate()
{
	_ui.schemeWidget->hide();
	_ui.inMultiplierWidget->setEnabled(false);
	_ui.clampCheckBox->setEnabled(false);
	_ui.inputLabel->setEnabled(false);
	_ui.constAttribPlaneWidget->show();
	_ui.constAttribPlaneWidget->updateUi();
}

} /* namespace NLQT */