#include "edittoolgadgets.h"

#include "tgl.h"

#include "toonz/tfxhandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tframehandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/stage.h"

#include "tools/tool.h"

#include "tfx.h"

#include "tparamcontainer.h"

#include "toonz/tcolumnfx.h"

#include "tdoubleparam.h"

#include "tparamset.h"

#include "toonz/stage.h"

#include "tundo.h"

#include "tparamuiconcept.h"

#include "historytypes.h"

using namespace EditToolGadgets;

GLdouble FxGadget::m_selectedColor[3] = {0.2, 0.8, 0.1};

//*************************************************************************************

//    FxGadgetUndo  definition

//*************************************************************************************

class FxGadgetUndo : public TUndo

{

	struct ParamData {

		TDoubleParamP m_param;

		double m_oldValue, m_newValue;

		bool m_wasKeyframe;

	};

private:

	std::vector<paramdata> m_params;</paramdata>

	int m_frame;

public:

	FxGadgetUndo(const std::vector<tdoubleparamp> ¶ms, int frame)</tdoubleparamp>

		: m_frame(frame)

	{

		m_params.resize(params.size());

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

			m_params[i].m_param = params[i];

			m_params[i].m_oldValue = params[i]->getValue(frame);

			m_params[i].m_newValue = m_params[i].m_oldValue;

			m_params[i].m_wasKeyframe = m_params[i].m_param->isKeyframe(frame);

		}

	}

	void onAdd()

	{

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

			m_params[i].m_newValue = m_params[i].m_param->getValue(m_frame);

		}

	}

	void undo() const

	{

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

			if (!m_params[i].m_wasKeyframe)

				m_params[i].m_param->deleteKeyframe(m_frame);

			else

				m_params[i].m_param->setValue(m_frame, m_params[i].m_oldValue);

		}

	}

	void redo() const

	{

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

			m_params[i].m_param->setValue(m_frame, m_params[i].m_newValue);

		}

	}

	int getSize() const { return sizeof(*this) + m_params.size() * sizeof(ParamData); }

	QString getHistoryString()

	{

		QString str = QObject::tr("Modify Fx Gadget  ");

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

			str += QString::fromStdString(m_params[i].m_param->getName());

			if (i != (int)m_params.size() - 1)

				str += QString::fromStdString(", ");

		}

		str += QString("  Frame : %1").arg(QString::number(m_frame + 1));

		return str;

	}

	int getHistoryType()

	{

		return HistoryType::Fx;

	}

};

//*************************************************************************************

//    GadgetDragTool  definition

//*************************************************************************************

class GadgetDragTool : public DragTool

{

	FxGadgetController *m_controller;

	FxGadget *m_gadget;

public:

	GadgetDragTool(FxGadgetController *controller, FxGadget *gadget)

		: m_controller(controller), m_gadget(gadget) {}

	TAffine getMatrix() const { return m_controller->getMatrix().inv(); }

	void leftButtonDown(const TPointD &pos, const TMouseEvent &e)

	{

		m_gadget->createUndo();

		m_gadget->leftButtonDown(getMatrix() * pos, e);

	}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

	{

		m_gadget->leftButtonDrag(getMatrix() * pos, e);

	}

	void leftButtonUp(const TPointD &pos, const TMouseEvent &e)

	{

		m_gadget->leftButtonUp(getMatrix() * pos, e);

		m_gadget->commitUndo();

	}

};

//*************************************************************************************

//    FxGadget  implementation

//*************************************************************************************

FxGadget::FxGadget(FxGadgetController *controller)

	: m_id(-1), m_selected(false), m_controller(controller), m_pixelSize(1), m_undo(0), m_scaleFactor(1)

{

	controller->assignId(this);

}

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

FxGadget::~FxGadget()

{

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

		m_params[i]->removeObserver(this);

}

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

void FxGadget::addParam(const TDoubleParamP ¶m)

{

	m_params.push_back(param);

	param->addObserver(this);

}

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

double FxGadget::getValue(const TDoubleParamP ¶m) const

{

	return param->getValue(m_controller->getCurrentFrame());

}

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

void FxGadget::setValue(const TDoubleParamP ¶m, double value)

{

	param->setValue(m_controller->getCurrentFrame(), value);

}

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

TPointD FxGadget::getValue(const TPointParamP ¶m) const

{

	return param->getValue(m_controller->getCurrentFrame());

}

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

void FxGadget::setValue(const TPointParamP ¶m, const TPointD &pos)

{

	param->setValue(m_controller->getCurrentFrame(), pos);

}

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

void FxGadget::setPixelSize()

{

	setPixelSize(sqrt(tglGetPixelSize2()));

}

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

void FxGadget::drawTooltip(const TPointD &tooltipPos, std::string tooltipPosText)

{

	double unit = sqrt(tglGetPixelSize2());

	glPushMatrix();

	glTranslated(tooltipPos.x, tooltipPos.y, 0.0);

	double sc = unit * 1.6;

	glScaled(sc, sc, 1);

	tglDrawText(TPointD(8, -3), tooltipPosText);

	glPopMatrix();

}

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

void FxGadget::drawDot(const TPointD &pos)

{

	double r = getPixelSize() * 3;

	tglDrawRect(pos.x - r, pos.y - r, pos.x + r, pos.y + r);

}

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

void FxGadget::onChange(const TParamChange &)

{

	m_controller->invalidateViewer();

}

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

void FxGadget::createUndo()

{

	assert(m_undo == 0);

	m_undo = new FxGadgetUndo(m_params, m_controller->getCurrentFrame());

}

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

void FxGadget::commitUndo()

{

	assert(m_undo);

	TUndoManager::manager()->add(m_undo);

	m_undo = 0;

}

//*************************************************************************************

//    Specific Gadget Concepts  definition

//*************************************************************************************

class PointFxGadget : public FxGadget

{

	TPointD m_pos;

	TDoubleParamP m_xParam, m_yParam;

public:

	PointFxGadget(FxGadgetController *controller, const TPointParamP ¶m)

		: FxGadget(controller), m_xParam(param->getX()), m_yParam(param->getY())

	{

		addParam(m_xParam);

		addParam(m_yParam);

	}

	PointFxGadget(FxGadgetController *controller, const TDoubleParamP &xParam, const TDoubleParamP &yParam)

		: FxGadget(controller), m_xParam(xParam), m_yParam(yParam)

	{

		addParam(m_xParam);

		addParam(m_yParam);

	}

	void draw(bool picking);

	TPointD getPoint() const { return TPointD(getValue(m_xParam), getValue(m_yParam)); }

	void leftButtonDown(const TPointD &pos, const TMouseEvent &);

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &);

	void leftButtonUp(const TPointD &pos, const TMouseEvent &);

};

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

void PointFxGadget::draw(bool picking)

{

	setPixelSize();

	if (isSelected())

		glColor3dv(m_selectedColor);

	else

		glColor3d(0, 0, 1);

	glPushName(getId());

	TPointD pos(getPoint());

	double unit = getPixelSize();

	glPushMatrix();

	glTranslated(pos.x, pos.y, 0);

	double r = unit * 3;

	double d = unit * 6;

	glBegin(GL_LINES);

	glVertex2d(-d, 0);

	glVertex2d(-r, 0);

	glVertex2d(d, 0);

	glVertex2d(r, 0);

	glVertex2d(0, -d);

	glVertex2d(0, -r);

	glVertex2d(0, d);

	glVertex2d(0, r);

	glEnd();

	tglDrawRect(-r, -r, r, r);

	glPopMatrix();

	glPopName();

	if (isSelected()) {

		drawTooltip(pos + TPointD(7, 3) * unit, getLabel());

	}

}

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

void PointFxGadget::leftButtonDown(const TPointD &pos, const TMouseEvent &)

{

}

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

void PointFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &)

{

	if (m_xParam)

		setValue(m_xParam, pos.x);

	if (m_yParam)

		setValue(m_yParam, pos.y);

}

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

void PointFxGadget::leftButtonUp(const TPointD &pos, const TMouseEvent &)

{

}

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

class RadiusFxGadget : public FxGadget

{

	TDoubleParamP m_radius;

	TPointParamP m_center;

public:

	RadiusFxGadget(

		FxGadgetController *controller,

		const TDoubleParamP &radius,

		const TPointParamP ¢er)

		: FxGadget(controller), m_radius(radius), m_center(center)

	{

		addParam(radius);

	}

	TPointD getCenter() const;

	void draw(bool picking);

	void leftButtonDown(const TPointD &pos, const TMouseEvent &);

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &);

	void leftButtonUp(const TPointD &pos, const TMouseEvent &);

};

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

TPointD RadiusFxGadget::getCenter() const

{

	return m_center ? getValue(m_center) : TPointD();

}

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

void RadiusFxGadget::draw(bool picking)

{

	if (!m_radius)

		return;

	setPixelSize();

	if (isSelected())

		glColor3dv(m_selectedColor);

	else

		glColor3d(0, 0, 1);

	glPushName(getId());

	double radius = getValue(m_radius);

	TPointD center = getCenter();

	glLineStipple(1, 0xAAAA);

	glEnable(GL_LINE_STIPPLE);

	tglDrawCircle(center, radius);

	glDisable(GL_LINE_STIPPLE);

	drawDot(center + TPointD(0.707, 0.707) * radius);

	glPopName();

	if (isSelected()) {

		drawTooltip(center + TPointD(0.707, 0.707) * radius, getLabel());

	}

}

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

void RadiusFxGadget::leftButtonDown(const TPointD &pos, const TMouseEvent &)

{

}

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

void RadiusFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &)

{

	setValue(m_radius, norm(pos - getCenter()));

}

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

void RadiusFxGadget::leftButtonUp(const TPointD &pos, const TMouseEvent &)

{

}

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

class DistanceFxGadget : public FxGadget

{

	TDoubleParamP m_distance, m_angle;

	int m_grabPos;

public:

	DistanceFxGadget(

		FxGadgetController *controller,

		const TDoubleParamP &distance,

		const TDoubleParamP &angle)

		: FxGadget(controller), m_distance(distance), m_angle(angle), m_grabPos(1)

	{

		addParam(distance);

		if (angle)

			addParam(angle);

	}

	TPointD getDirection() const

	{

		if (!m_angle)

			return TPointD(1.0, 0.0);

		double angle = getValue(m_angle);

		return TPointD(cos(angle), sin(angle));

	}

	void draw(bool picking);

	void leftButtonDown(const TPointD &pos, const TMouseEvent &);

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &);

	void leftButtonUp(const TPointD &pos, const TMouseEvent &);

};

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

void DistanceFxGadget::draw(bool picking)

{

	if (!m_distance)

		return;

	setPixelSize();

	glColor3d(0, 0, 1);

	double d = getValue(m_distance) * getScaleFactor();

	TPointD dir(getDirection());

	TPointD u = rotate90(dir) * (getPixelSize() * 10);

	tglDrawSegment(-u, u);

	glPushName(getId());

	TPointD b, c;

	b = dir * (d * 0.5);

	c = b - dir * d;

	tglDrawSegment(b - u, b + u);

	tglDrawCircle(b, getPixelSize() * 5);

	tglDrawSegment(c - u, c + u);

	tglDrawCircle(c, getPixelSize() * 5);

	glPopName();

	glLineStipple(1, 0xAAAA);

	glEnable(GL_LINE_STIPPLE);

	tglDrawSegment(b, c);

	glDisable(GL_LINE_STIPPLE);

	if (isSelected()) {

		drawTooltip(b + TPointD(5, 5) * getPixelSize(), getLabel());

	}

}

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

void DistanceFxGadget::leftButtonDown(const TPointD &pos, const TMouseEvent &)

{

	m_grabPos = (pos.x > 0.0) ? 1 : -1;

}

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

void DistanceFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &)

{

	double v = (pos * getDirection()) / getScaleFactor();

	v = v * 2 * m_grabPos;

	setValue(m_distance, v);

}

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

void DistanceFxGadget::leftButtonUp(const TPointD &pos, const TMouseEvent &)

{

}

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

class AngleFxGadget : public FxGadget

{

	TDoubleParamP m_param;

	TPointD m_pos;

public:

	AngleFxGadget(FxGadgetController *controller, const TDoubleParamP ¶m, const TPointD &pos);

	void draw(bool picking);

	void leftButtonDown(const TPointD &pos, const TMouseEvent &);

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &);

	void leftButtonUp(const TPointD &pos, const TMouseEvent &);

};

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

AngleFxGadget::AngleFxGadget(FxGadgetController *controller, const TDoubleParamP ¶m, const TPointD &pos)

	: FxGadget(controller), m_param(param), m_pos(pos)

{

	addParam(param);

}

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

void AngleFxGadget::draw(bool picking)

{

	if (isSelected())

		glColor3dv(m_selectedColor);

	else

		glColor3d(0, 0, 1);

	glPushName(getId());

	double pixelSize = sqrt(tglGetPixelSize2());

	double r = pixelSize * 40;

	double a = pixelSize * 10, b = pixelSize * 5;

	tglDrawCircle(m_pos, r);

	double phi = getValue(m_param);

	glPushMatrix();

	glTranslated(m_pos.x, m_pos.y, 0);

	glRotated(phi, 0, 0, 1);

	glBegin(GL_LINES);

	glVertex2d(0, 0);

	glVertex2d(r, 0);

	glVertex2d(r, 0);

	glVertex2d(r - a, b);

	glVertex2d(r, 0);

	glVertex2d(r - a, -b);

	glEnd();

	glPopMatrix();

	glPopName();

	if (isSelected()) {

		drawTooltip(m_pos + TPointD(0.707, 0.707) * r, getLabel());

	}

}

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

void AngleFxGadget::leftButtonDown(const TPointD &pos, const TMouseEvent &)

{

}

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

void AngleFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &)

{

	TPointD d = pos - m_pos;

	double phi = atan2(d.y, d.x);

	setValue(m_param, TConsts::invOf_pi_180 * phi);

}

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

void AngleFxGadget::leftButtonUp(const TPointD &pos, const TMouseEvent &)

{

}

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

class DiamondFxGadget : public FxGadget

{

	TDoubleParamP m_param;

public:

	DiamondFxGadget(FxGadgetController *controller, const TDoubleParamP ¶m)

		: FxGadget(controller), m_param(param)

	{

		addParam(param);

	}

	void draw(bool picking);

	void leftButtonDown(const TPointD &pos, const TMouseEvent &) {}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &);

	void leftButtonUp(const TPointD &pos, const TMouseEvent &) {}

};

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

void DiamondFxGadget::draw(bool picking)

{

	setPixelSize();

	if (isSelected())

		glColor3dv(m_selectedColor);

	else

		glColor3d(0, 0, 1);

	glPushName(getId());

	double size = getValue(m_param);

	double r = 3 * getPixelSize();

	glLineStipple(1, 0xAAAA);

	glEnable(GL_LINE_STIPPLE);

	glBegin(GL_LINES);

	glVertex2d(-size + r, r);

	glVertex2d(-r, size - r);

	glVertex2d(r, size - r);

	glVertex2d(size - r, r);

	glVertex2d(size - r, -r);

	glVertex2d(r, -size + r);

	glVertex2d(-r, -size + r);

	glVertex2d(-size + r, -r);

	glEnd();

	glDisable(GL_LINE_STIPPLE);

	drawDot(-size, 0);

	drawDot(size, 0);

	drawDot(0, -size);

	drawDot(0, size);

	double d = getPixelSize() * 3;

	glPopName();

	if (isSelected()) {

		drawTooltip(TPointD(d, size - d), getLabel());

	}

}

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

void DiamondFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &)

{

	double sz = fabs(pos.x) + fabs(pos.y);

	if (sz < 0.1)

		sz = 0.1;

	setValue(m_param, sz);

}

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

class SizeFxGadget : public FxGadget

{

	TDoubleParamP m_lx, m_ly;

public:

	SizeFxGadget(FxGadgetController *controller, const TDoubleParamP &lx, const TDoubleParamP &ly)

		: FxGadget(controller), m_lx(lx), m_ly(ly)

	{

		addParam(lx);

		if (ly)

			addParam(ly);

	}

	void draw(bool picking);

	void leftButtonDown(const TPointD &pos, const TMouseEvent &) {}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &);

	void leftButtonUp(const TPointD &pos, const TMouseEvent &) {}

};

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

void SizeFxGadget::draw(bool picking)

{

	setPixelSize();

	if (isSelected())

		glColor3dv(m_selectedColor);

	else

		glColor3d(0, 0, 1);

	glPushName(getId());

	double lx = getValue(m_lx), ly = m_ly ? getValue(m_ly) : lx;

	double r = getPixelSize() * 3;

	glLineStipple(1, 0xCCCC);

	glEnable(GL_LINE_STIPPLE);

	glBegin(GL_LINES);

	glVertex2d(0, 0);

	glVertex2d(lx, 0);

	glVertex2d(0, 0);

	glVertex2d(0, ly);

	glVertex2d(lx, 0);

	glVertex2d(lx, ly - r);

	glVertex2d(0, ly);

	glVertex2d(lx - r, ly);

	glEnd();

	glDisable(GL_LINE_STIPPLE);

	drawDot(lx, ly);

	double d = getPixelSize() * 3;

	glPopName();

	if (isSelected()) {

		drawTooltip(TPointD(lx, ly), getLabel());

	}

}

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

void SizeFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &)

{

	if (m_ly)

		setValue(m_lx, std::max(pos.x, 0.1)), setValue(m_ly, std::max(pos.y, 0.1));

	else

		setValue(m_lx, std::max({pos.x, pos.y, 0.1}));

}

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

class RectFxGadget : public FxGadget

{

	TDoubleParamP m_width, m_height;

	TPointParamP m_center;

	int m_picked;

public:

	enum { None,

		   Corner,

		   HorizontalSide,

		   VerticalSide };

public:

	RectFxGadget(FxGadgetController *controller,

				 const TDoubleParamP &width,

				 const TDoubleParamP &height,

				 const TPointParamP ¢er)

		: FxGadget(controller), m_width(width), m_height(height), m_center(center), m_picked(None)

	{

		addParam(width);

		addParam(height);

		if (center)

			addParam(center->getX()), addParam(center->getY());

	}

	TPointD getCenter() const { return m_center ? getValue(m_center) : TPointD(); }

	void draw(bool picking);

	void leftButtonDown(const TPointD &pos, const TMouseEvent &);

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &);

	void leftButtonUp(const TPointD &pos, const TMouseEvent &) {}

};

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

void RectFxGadget::draw(bool picking)

{

	setPixelSize();

	if (isSelected())

		glColor3dv(m_selectedColor);

	else

		glColor3d(0, 0, 1);

	glPushName(getId());

	glPushMatrix();

	TPointD center = getCenter();

	glTranslated(center.x, center.y, 0);

	double w_2 = 0.5 * getValue(m_width);

	double h_2 = 0.5 * getValue(m_height);

	double r = getPixelSize() * 3;

	glLineStipple(1, 0xCCCC);

	glEnable(GL_LINE_STIPPLE);

	glBegin(GL_LINES);

	glVertex2d(-w_2 + r, -h_2);

	glVertex2d(w_2 - r, -h_2);

	glVertex2d(-w_2 + r, h_2);

	glVertex2d(w_2 - r, h_2);

	glVertex2d(-w_2, -h_2 + r);

	glVertex2d(-w_2, h_2 - r);

	glVertex2d(w_2, -h_2 + r);

	glVertex2d(w_2, h_2 - r);

	glEnd();

	glDisable(GL_LINE_STIPPLE);

	drawDot(w_2, h_2);

	drawDot(-w_2, h_2);

	drawDot(w_2, -h_2);

	drawDot(-w_2, -h_2);

	glPopMatrix();

}

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

void RectFxGadget::leftButtonDown(const TPointD &ppos, const TMouseEvent &)

{

	TPointD pos = ppos - getCenter();

	m_picked = None;

	double w_2 = 0.5 * getValue(m_width);

	double h_2 = 0.5 * getValue(m_height);

	double x = fabs(pos.x);

	double y = fabs(pos.y);

	double r = getPixelSize() * 15;

	if (fabs(w_2 - x) < r && fabs(y - h_2) < r)

		m_picked = Corner;

	else if (fabs(w_2 - x) < r && y < h_2)

		m_picked = VerticalSide;

	else if (fabs(h_2 - y) < r && x < w_2)

		m_picked = HorizontalSide;

}

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

void RectFxGadget::leftButtonDrag(const TPointD &ppos, const TMouseEvent &)

{

	TPointD pos = ppos - getCenter();

	double w = fabs(pos.x), h = fabs(pos.y);

	if (m_picked == Corner || m_picked == VerticalSide)

		setValue(m_width, 2.0 * w);

	if (m_picked == Corner || m_picked == HorizontalSide)

		setValue(m_height, 2.0 * h);

}

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

class PolarFxGadget : public FxGadget

{

	TPointD m_pos;

	TDoubleParamP m_phiParam, m_lengthParam;

public:

	PolarFxGadget(

		FxGadgetController *controller,

		const TPointD &pos,

		const TDoubleParamP &phiParam,

		const TDoubleParamP &lengthParam)

		: FxGadget(controller), m_pos(pos), m_phiParam(phiParam), m_lengthParam(lengthParam)

	{

		addParam(phiParam);

		addParam(lengthParam);

	}

	void draw(bool picking)

	{

		setPixelSize();

		if (isSelected())

			glColor3dv(m_selectedColor);

		else

			glColor3d(0, 0, 1);

		glPushName(getId());

		double pixelSize = getPixelSize();

		double r = getValue(m_lengthParam);

		double a = pixelSize * 10, b = pixelSize * 5, c = pixelSize * 4;

		// tglDrawCircle(m_pos, r);

		double phi = getValue(m_phiParam);

		glPushMatrix();

		glTranslated(m_pos.x, m_pos.y, 0);

		glRotated(phi, 0, 0, 1);

		double rr = r - c;

		if (rr > 0) {

			glLineStipple(1, 0xAAAA);

			glEnable(GL_LINE_STIPPLE);

			glBegin(GL_LINE_STRIP);

			glVertex2d(0, 0);

			glVertex2d(rr, 0);

			glEnd();

			glDisable(GL_LINE_STIPPLE);

		}

		glBegin(GL_LINES);

		glVertex2d(rr, 0);

		glVertex2d(rr - a, b);

		glVertex2d(rr, 0);

		glVertex2d(rr - a, -b);

		glEnd();