/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkInteractorObserverWrap.h"
#include "vtkInteractorStyleWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkRenderWindowInteractorWrap.h"
#include "vtkPropWrap.h"
#include "vtkActor2DWrap.h"
#include "vtkProp3DWrap.h"
#include "vtkTDxInteractorStyleWrap.h"
#include "../../plus/plus.h"

using namespace v8;

extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkInteractorStyleWrap::ptpl;

VtkInteractorStyleWrap::VtkInteractorStyleWrap()
{ }

VtkInteractorStyleWrap::VtkInteractorStyleWrap(vtkSmartPointer<vtkInteractorStyle> _native)
{ native = _native; }

VtkInteractorStyleWrap::~VtkInteractorStyleWrap()
{ }

void VtkInteractorStyleWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkInteractorStyle").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("InteractorStyle").ToLocalChecked(), ConstructorGetter);
}

void VtkInteractorStyleWrap::ConstructorGetter(
	v8::Local<v8::String> property,
	const Nan::PropertyCallbackInfo<v8::Value>& info)
{
	InitPtpl();
	info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}

void VtkInteractorStyleWrap::InitPtpl()
{
	if (!ptpl.IsEmpty()) return;
	v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
	VtkInteractorObserverWrap::InitPtpl( );
	tpl->Inherit(Nan::New<FunctionTemplate>(VtkInteractorObserverWrap::ptpl));
	tpl->SetClassName(Nan::New("VtkInteractorStyleWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "AutoAdjustCameraClippingRangeOff", AutoAdjustCameraClippingRangeOff);
	Nan::SetPrototypeMethod(tpl, "autoAdjustCameraClippingRangeOff", AutoAdjustCameraClippingRangeOff);

	Nan::SetPrototypeMethod(tpl, "AutoAdjustCameraClippingRangeOn", AutoAdjustCameraClippingRangeOn);
	Nan::SetPrototypeMethod(tpl, "autoAdjustCameraClippingRangeOn", AutoAdjustCameraClippingRangeOn);

	Nan::SetPrototypeMethod(tpl, "Dolly", Dolly);
	Nan::SetPrototypeMethod(tpl, "dolly", Dolly);

	Nan::SetPrototypeMethod(tpl, "EndDolly", EndDolly);
	Nan::SetPrototypeMethod(tpl, "endDolly", EndDolly);

	Nan::SetPrototypeMethod(tpl, "EndPan", EndPan);
	Nan::SetPrototypeMethod(tpl, "endPan", EndPan);

	Nan::SetPrototypeMethod(tpl, "EndRotate", EndRotate);
	Nan::SetPrototypeMethod(tpl, "endRotate", EndRotate);

	Nan::SetPrototypeMethod(tpl, "EndSpin", EndSpin);
	Nan::SetPrototypeMethod(tpl, "endSpin", EndSpin);

	Nan::SetPrototypeMethod(tpl, "EndTimer", EndTimer);
	Nan::SetPrototypeMethod(tpl, "endTimer", EndTimer);

	Nan::SetPrototypeMethod(tpl, "EndTwoPointer", EndTwoPointer);
	Nan::SetPrototypeMethod(tpl, "endTwoPointer", EndTwoPointer);

	Nan::SetPrototypeMethod(tpl, "EndUniformScale", EndUniformScale);
	Nan::SetPrototypeMethod(tpl, "endUniformScale", EndUniformScale);

	Nan::SetPrototypeMethod(tpl, "EndZoom", EndZoom);
	Nan::SetPrototypeMethod(tpl, "endZoom", EndZoom);

	Nan::SetPrototypeMethod(tpl, "FindPokedRenderer", FindPokedRenderer);
	Nan::SetPrototypeMethod(tpl, "findPokedRenderer", FindPokedRenderer);

	Nan::SetPrototypeMethod(tpl, "GetAutoAdjustCameraClippingRange", GetAutoAdjustCameraClippingRange);
	Nan::SetPrototypeMethod(tpl, "getAutoAdjustCameraClippingRange", GetAutoAdjustCameraClippingRange);

	Nan::SetPrototypeMethod(tpl, "GetAutoAdjustCameraClippingRangeMaxValue", GetAutoAdjustCameraClippingRangeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getAutoAdjustCameraClippingRangeMaxValue", GetAutoAdjustCameraClippingRangeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetAutoAdjustCameraClippingRangeMinValue", GetAutoAdjustCameraClippingRangeMinValue);
	Nan::SetPrototypeMethod(tpl, "getAutoAdjustCameraClippingRangeMinValue", GetAutoAdjustCameraClippingRangeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetHandleObservers", GetHandleObservers);
	Nan::SetPrototypeMethod(tpl, "getHandleObservers", GetHandleObservers);

	Nan::SetPrototypeMethod(tpl, "GetMouseWheelMotionFactor", GetMouseWheelMotionFactor);
	Nan::SetPrototypeMethod(tpl, "getMouseWheelMotionFactor", GetMouseWheelMotionFactor);

	Nan::SetPrototypeMethod(tpl, "GetPickColor", GetPickColor);
	Nan::SetPrototypeMethod(tpl, "getPickColor", GetPickColor);

	Nan::SetPrototypeMethod(tpl, "GetState", GetState);
	Nan::SetPrototypeMethod(tpl, "getState", GetState);

	Nan::SetPrototypeMethod(tpl, "GetTDxStyle", GetTDxStyle);
	Nan::SetPrototypeMethod(tpl, "getTDxStyle", GetTDxStyle);

	Nan::SetPrototypeMethod(tpl, "GetTimerDuration", GetTimerDuration);
	Nan::SetPrototypeMethod(tpl, "getTimerDuration", GetTimerDuration);

	Nan::SetPrototypeMethod(tpl, "GetTimerDurationMaxValue", GetTimerDurationMaxValue);
	Nan::SetPrototypeMethod(tpl, "getTimerDurationMaxValue", GetTimerDurationMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetTimerDurationMinValue", GetTimerDurationMinValue);
	Nan::SetPrototypeMethod(tpl, "getTimerDurationMinValue", GetTimerDurationMinValue);

	Nan::SetPrototypeMethod(tpl, "GetUseTimers", GetUseTimers);
	Nan::SetPrototypeMethod(tpl, "getUseTimers", GetUseTimers);

	Nan::SetPrototypeMethod(tpl, "HandleObserversOff", HandleObserversOff);
	Nan::SetPrototypeMethod(tpl, "handleObserversOff", HandleObserversOff);

	Nan::SetPrototypeMethod(tpl, "HandleObserversOn", HandleObserversOn);
	Nan::SetPrototypeMethod(tpl, "handleObserversOn", HandleObserversOn);

	Nan::SetPrototypeMethod(tpl, "HighlightActor2D", HighlightActor2D);
	Nan::SetPrototypeMethod(tpl, "highlightActor2D", HighlightActor2D);

	Nan::SetPrototypeMethod(tpl, "HighlightProp", HighlightProp);
	Nan::SetPrototypeMethod(tpl, "highlightProp", HighlightProp);

	Nan::SetPrototypeMethod(tpl, "HighlightProp3D", HighlightProp3D);
	Nan::SetPrototypeMethod(tpl, "highlightProp3D", HighlightProp3D);

	Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
	Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);

	Nan::SetPrototypeMethod(tpl, "OnChar", OnChar);
	Nan::SetPrototypeMethod(tpl, "onChar", OnChar);

	Nan::SetPrototypeMethod(tpl, "OnConfigure", OnConfigure);
	Nan::SetPrototypeMethod(tpl, "onConfigure", OnConfigure);

	Nan::SetPrototypeMethod(tpl, "OnEnter", OnEnter);
	Nan::SetPrototypeMethod(tpl, "onEnter", OnEnter);

	Nan::SetPrototypeMethod(tpl, "OnExpose", OnExpose);
	Nan::SetPrototypeMethod(tpl, "onExpose", OnExpose);

	Nan::SetPrototypeMethod(tpl, "OnFifthButtonDown", OnFifthButtonDown);
	Nan::SetPrototypeMethod(tpl, "onFifthButtonDown", OnFifthButtonDown);

	Nan::SetPrototypeMethod(tpl, "OnFifthButtonUp", OnFifthButtonUp);
	Nan::SetPrototypeMethod(tpl, "onFifthButtonUp", OnFifthButtonUp);

	Nan::SetPrototypeMethod(tpl, "OnFourthButtonDown", OnFourthButtonDown);
	Nan::SetPrototypeMethod(tpl, "onFourthButtonDown", OnFourthButtonDown);

	Nan::SetPrototypeMethod(tpl, "OnFourthButtonUp", OnFourthButtonUp);
	Nan::SetPrototypeMethod(tpl, "onFourthButtonUp", OnFourthButtonUp);

	Nan::SetPrototypeMethod(tpl, "OnKeyDown", OnKeyDown);
	Nan::SetPrototypeMethod(tpl, "onKeyDown", OnKeyDown);

	Nan::SetPrototypeMethod(tpl, "OnKeyPress", OnKeyPress);
	Nan::SetPrototypeMethod(tpl, "onKeyPress", OnKeyPress);

	Nan::SetPrototypeMethod(tpl, "OnKeyRelease", OnKeyRelease);
	Nan::SetPrototypeMethod(tpl, "onKeyRelease", OnKeyRelease);

	Nan::SetPrototypeMethod(tpl, "OnKeyUp", OnKeyUp);
	Nan::SetPrototypeMethod(tpl, "onKeyUp", OnKeyUp);

	Nan::SetPrototypeMethod(tpl, "OnLeave", OnLeave);
	Nan::SetPrototypeMethod(tpl, "onLeave", OnLeave);

	Nan::SetPrototypeMethod(tpl, "OnLeftButtonDown", OnLeftButtonDown);
	Nan::SetPrototypeMethod(tpl, "onLeftButtonDown", OnLeftButtonDown);

	Nan::SetPrototypeMethod(tpl, "OnLeftButtonUp", OnLeftButtonUp);
	Nan::SetPrototypeMethod(tpl, "onLeftButtonUp", OnLeftButtonUp);

	Nan::SetPrototypeMethod(tpl, "OnLongTap", OnLongTap);
	Nan::SetPrototypeMethod(tpl, "onLongTap", OnLongTap);

	Nan::SetPrototypeMethod(tpl, "OnMiddleButtonDown", OnMiddleButtonDown);
	Nan::SetPrototypeMethod(tpl, "onMiddleButtonDown", OnMiddleButtonDown);

	Nan::SetPrototypeMethod(tpl, "OnMiddleButtonUp", OnMiddleButtonUp);
	Nan::SetPrototypeMethod(tpl, "onMiddleButtonUp", OnMiddleButtonUp);

	Nan::SetPrototypeMethod(tpl, "OnMouseMove", OnMouseMove);
	Nan::SetPrototypeMethod(tpl, "onMouseMove", OnMouseMove);

	Nan::SetPrototypeMethod(tpl, "OnMouseWheelBackward", OnMouseWheelBackward);
	Nan::SetPrototypeMethod(tpl, "onMouseWheelBackward", OnMouseWheelBackward);

	Nan::SetPrototypeMethod(tpl, "OnMouseWheelForward", OnMouseWheelForward);
	Nan::SetPrototypeMethod(tpl, "onMouseWheelForward", OnMouseWheelForward);

	Nan::SetPrototypeMethod(tpl, "OnPan", OnPan);
	Nan::SetPrototypeMethod(tpl, "onPan", OnPan);

	Nan::SetPrototypeMethod(tpl, "OnPinch", OnPinch);
	Nan::SetPrototypeMethod(tpl, "onPinch", OnPinch);

	Nan::SetPrototypeMethod(tpl, "OnRightButtonDown", OnRightButtonDown);
	Nan::SetPrototypeMethod(tpl, "onRightButtonDown", OnRightButtonDown);

	Nan::SetPrototypeMethod(tpl, "OnRightButtonUp", OnRightButtonUp);
	Nan::SetPrototypeMethod(tpl, "onRightButtonUp", OnRightButtonUp);

	Nan::SetPrototypeMethod(tpl, "OnRotate", OnRotate);
	Nan::SetPrototypeMethod(tpl, "onRotate", OnRotate);

	Nan::SetPrototypeMethod(tpl, "OnSwipe", OnSwipe);
	Nan::SetPrototypeMethod(tpl, "onSwipe", OnSwipe);

	Nan::SetPrototypeMethod(tpl, "OnTap", OnTap);
	Nan::SetPrototypeMethod(tpl, "onTap", OnTap);

	Nan::SetPrototypeMethod(tpl, "OnTimer", OnTimer);
	Nan::SetPrototypeMethod(tpl, "onTimer", OnTimer);

	Nan::SetPrototypeMethod(tpl, "Pan", Pan);
	Nan::SetPrototypeMethod(tpl, "pan", Pan);

	Nan::SetPrototypeMethod(tpl, "Rotate", Rotate);
	Nan::SetPrototypeMethod(tpl, "rotate", Rotate);

	Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
	Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);

	Nan::SetPrototypeMethod(tpl, "SetAutoAdjustCameraClippingRange", SetAutoAdjustCameraClippingRange);
	Nan::SetPrototypeMethod(tpl, "setAutoAdjustCameraClippingRange", SetAutoAdjustCameraClippingRange);

	Nan::SetPrototypeMethod(tpl, "SetEnabled", SetEnabled);
	Nan::SetPrototypeMethod(tpl, "setEnabled", SetEnabled);

	Nan::SetPrototypeMethod(tpl, "SetHandleObservers", SetHandleObservers);
	Nan::SetPrototypeMethod(tpl, "setHandleObservers", SetHandleObservers);

	Nan::SetPrototypeMethod(tpl, "SetInteractor", SetInteractor);
	Nan::SetPrototypeMethod(tpl, "setInteractor", SetInteractor);

	Nan::SetPrototypeMethod(tpl, "SetMouseWheelMotionFactor", SetMouseWheelMotionFactor);
	Nan::SetPrototypeMethod(tpl, "setMouseWheelMotionFactor", SetMouseWheelMotionFactor);

	Nan::SetPrototypeMethod(tpl, "SetPickColor", SetPickColor);
	Nan::SetPrototypeMethod(tpl, "setPickColor", SetPickColor);

	Nan::SetPrototypeMethod(tpl, "SetTDxStyle", SetTDxStyle);
	Nan::SetPrototypeMethod(tpl, "setTDxStyle", SetTDxStyle);

	Nan::SetPrototypeMethod(tpl, "SetTimerDuration", SetTimerDuration);
	Nan::SetPrototypeMethod(tpl, "setTimerDuration", SetTimerDuration);

	Nan::SetPrototypeMethod(tpl, "SetUseTimers", SetUseTimers);
	Nan::SetPrototypeMethod(tpl, "setUseTimers", SetUseTimers);

	Nan::SetPrototypeMethod(tpl, "Spin", Spin);
	Nan::SetPrototypeMethod(tpl, "spin", Spin);

	Nan::SetPrototypeMethod(tpl, "StartAnimate", StartAnimate);
	Nan::SetPrototypeMethod(tpl, "startAnimate", StartAnimate);

	Nan::SetPrototypeMethod(tpl, "StartDolly", StartDolly);
	Nan::SetPrototypeMethod(tpl, "startDolly", StartDolly);

	Nan::SetPrototypeMethod(tpl, "StartPan", StartPan);
	Nan::SetPrototypeMethod(tpl, "startPan", StartPan);

	Nan::SetPrototypeMethod(tpl, "StartRotate", StartRotate);
	Nan::SetPrototypeMethod(tpl, "startRotate", StartRotate);

	Nan::SetPrototypeMethod(tpl, "StartSpin", StartSpin);
	Nan::SetPrototypeMethod(tpl, "startSpin", StartSpin);

	Nan::SetPrototypeMethod(tpl, "StartState", StartState);
	Nan::SetPrototypeMethod(tpl, "startState", StartState);

	Nan::SetPrototypeMethod(tpl, "StartTimer", StartTimer);
	Nan::SetPrototypeMethod(tpl, "startTimer", StartTimer);

	Nan::SetPrototypeMethod(tpl, "StartTwoPointer", StartTwoPointer);
	Nan::SetPrototypeMethod(tpl, "startTwoPointer", StartTwoPointer);

	Nan::SetPrototypeMethod(tpl, "StartUniformScale", StartUniformScale);
	Nan::SetPrototypeMethod(tpl, "startUniformScale", StartUniformScale);

	Nan::SetPrototypeMethod(tpl, "StartZoom", StartZoom);
	Nan::SetPrototypeMethod(tpl, "startZoom", StartZoom);

	Nan::SetPrototypeMethod(tpl, "StopAnimate", StopAnimate);
	Nan::SetPrototypeMethod(tpl, "stopAnimate", StopAnimate);

	Nan::SetPrototypeMethod(tpl, "StopState", StopState);
	Nan::SetPrototypeMethod(tpl, "stopState", StopState);

	Nan::SetPrototypeMethod(tpl, "UniformScale", UniformScale);
	Nan::SetPrototypeMethod(tpl, "uniformScale", UniformScale);

	Nan::SetPrototypeMethod(tpl, "UseTimersOff", UseTimersOff);
	Nan::SetPrototypeMethod(tpl, "useTimersOff", UseTimersOff);

	Nan::SetPrototypeMethod(tpl, "UseTimersOn", UseTimersOn);
	Nan::SetPrototypeMethod(tpl, "useTimersOn", UseTimersOn);

	Nan::SetPrototypeMethod(tpl, "Zoom", Zoom);
	Nan::SetPrototypeMethod(tpl, "zoom", Zoom);

#ifdef VTK_NODE_PLUS_VTKINTERACTORSTYLEWRAP_INITPTPL
	VTK_NODE_PLUS_VTKINTERACTORSTYLEWRAP_INITPTPL
#endif
	ptpl.Reset( tpl );
}

void VtkInteractorStyleWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	if(!info.IsConstructCall())
	{
		Nan::ThrowError("Constructor not called in a construct call.");
		return;
	}

	if(info.Length() == 0)
	{
		vtkSmartPointer<vtkInteractorStyle> native = vtkSmartPointer<vtkInteractorStyle>::New();
		VtkInteractorStyleWrap* obj = new VtkInteractorStyleWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

	info.GetReturnValue().Set(info.This());
}

void VtkInteractorStyleWrap::AutoAdjustCameraClippingRangeOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->AutoAdjustCameraClippingRangeOff();
}

void VtkInteractorStyleWrap::AutoAdjustCameraClippingRangeOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->AutoAdjustCameraClippingRangeOn();
}

void VtkInteractorStyleWrap::Dolly(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Dolly();
}

void VtkInteractorStyleWrap::EndDolly(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EndDolly();
}

void VtkInteractorStyleWrap::EndPan(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EndPan();
}

void VtkInteractorStyleWrap::EndRotate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EndRotate();
}

void VtkInteractorStyleWrap::EndSpin(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EndSpin();
}

void VtkInteractorStyleWrap::EndTimer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EndTimer();
}

void VtkInteractorStyleWrap::EndTwoPointer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EndTwoPointer();
}

void VtkInteractorStyleWrap::EndUniformScale(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EndUniformScale();
}

void VtkInteractorStyleWrap::EndZoom(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->EndZoom();
}

void VtkInteractorStyleWrap::FindPokedRenderer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->FindPokedRenderer(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::GetAutoAdjustCameraClippingRange(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAutoAdjustCameraClippingRange();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::GetAutoAdjustCameraClippingRangeMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAutoAdjustCameraClippingRangeMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::GetAutoAdjustCameraClippingRangeMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAutoAdjustCameraClippingRangeMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::GetHandleObservers(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetHandleObservers();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::GetMouseWheelMotionFactor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMouseWheelMotionFactor();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::GetPickColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPickColor();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkInteractorStyleWrap::GetState(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetState();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::GetTDxStyle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	vtkTDxInteractorStyle * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTDxStyle();
	VtkTDxInteractorStyleWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkTDxInteractorStyleWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkTDxInteractorStyleWrap *w = new VtkTDxInteractorStyleWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkInteractorStyleWrap::GetTimerDuration(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	unsigned int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTimerDuration();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::GetTimerDurationMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	unsigned int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTimerDurationMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::GetTimerDurationMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	unsigned int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTimerDurationMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::GetUseTimers(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetUseTimers();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkInteractorStyleWrap::HandleObserversOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->HandleObserversOff();
}

void VtkInteractorStyleWrap::HandleObserversOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->HandleObserversOn();
}

void VtkInteractorStyleWrap::HighlightActor2D(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkActor2DWrap::ptpl))->HasInstance(info[0]))
	{
		VtkActor2DWrap *a0 = ObjectWrap::Unwrap<VtkActor2DWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->HighlightActor2D(
			(vtkActor2D *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::HighlightProp(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPropWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPropWrap *a0 = ObjectWrap::Unwrap<VtkPropWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->HighlightProp(
			(vtkProp *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::HighlightProp3D(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkProp3DWrap::ptpl))->HasInstance(info[0]))
	{
		VtkProp3DWrap *a0 = ObjectWrap::Unwrap<VtkProp3DWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->HighlightProp3D(
			(vtkProp3D *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	vtkInteractorStyle * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->NewInstance();
	VtkInteractorStyleWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInteractorStyleWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInteractorStyleWrap *w = new VtkInteractorStyleWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkInteractorStyleWrap::OnChar(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnChar();
}

void VtkInteractorStyleWrap::OnConfigure(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnConfigure();
}

void VtkInteractorStyleWrap::OnEnter(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnEnter();
}

void VtkInteractorStyleWrap::OnExpose(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnExpose();
}

void VtkInteractorStyleWrap::OnFifthButtonDown(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnFifthButtonDown();
}

void VtkInteractorStyleWrap::OnFifthButtonUp(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnFifthButtonUp();
}

void VtkInteractorStyleWrap::OnFourthButtonDown(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnFourthButtonDown();
}

void VtkInteractorStyleWrap::OnFourthButtonUp(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnFourthButtonUp();
}

void VtkInteractorStyleWrap::OnKeyDown(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnKeyDown();
}

void VtkInteractorStyleWrap::OnKeyPress(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnKeyPress();
}

void VtkInteractorStyleWrap::OnKeyRelease(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnKeyRelease();
}

void VtkInteractorStyleWrap::OnKeyUp(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnKeyUp();
}

void VtkInteractorStyleWrap::OnLeave(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnLeave();
}

void VtkInteractorStyleWrap::OnLeftButtonDown(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnLeftButtonDown();
}

void VtkInteractorStyleWrap::OnLeftButtonUp(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnLeftButtonUp();
}

void VtkInteractorStyleWrap::OnLongTap(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnLongTap();
}

void VtkInteractorStyleWrap::OnMiddleButtonDown(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnMiddleButtonDown();
}

void VtkInteractorStyleWrap::OnMiddleButtonUp(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnMiddleButtonUp();
}

void VtkInteractorStyleWrap::OnMouseMove(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnMouseMove();
}

void VtkInteractorStyleWrap::OnMouseWheelBackward(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnMouseWheelBackward();
}

void VtkInteractorStyleWrap::OnMouseWheelForward(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnMouseWheelForward();
}

void VtkInteractorStyleWrap::OnPan(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnPan();
}

void VtkInteractorStyleWrap::OnPinch(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnPinch();
}

void VtkInteractorStyleWrap::OnRightButtonDown(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnRightButtonDown();
}

void VtkInteractorStyleWrap::OnRightButtonUp(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnRightButtonUp();
}

void VtkInteractorStyleWrap::OnRotate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnRotate();
}

void VtkInteractorStyleWrap::OnSwipe(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnSwipe();
}

void VtkInteractorStyleWrap::OnTap(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnTap();
}

void VtkInteractorStyleWrap::OnTimer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->OnTimer();
}

void VtkInteractorStyleWrap::Pan(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Pan();
}

void VtkInteractorStyleWrap::Rotate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Rotate();
}

void VtkInteractorStyleWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectBaseWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectBaseWrap *a0 = ObjectWrap::Unwrap<VtkObjectBaseWrap>(info[0]->ToObject());
		vtkInteractorStyle * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObjectBase *) a0->native.GetPointer()
		);
		VtkInteractorStyleWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkInteractorStyleWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkInteractorStyleWrap *w = new VtkInteractorStyleWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::SetAutoAdjustCameraClippingRange(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetAutoAdjustCameraClippingRange(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::SetEnabled(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEnabled(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::SetHandleObservers(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetHandleObservers(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::SetInteractor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkRenderWindowInteractorWrap::ptpl))->HasInstance(info[0]))
	{
		VtkRenderWindowInteractorWrap *a0 = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetInteractor(
			(vtkRenderWindowInteractor *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::SetMouseWheelMotionFactor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMouseWheelMotionFactor(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::SetPickColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPickColor(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPickColor(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetPickColor(
					info[0]->NumberValue(),
					info[1]->NumberValue(),
					info[2]->NumberValue()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::SetTDxStyle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkTDxInteractorStyleWrap::ptpl))->HasInstance(info[0]))
	{
		VtkTDxInteractorStyleWrap *a0 = ObjectWrap::Unwrap<VtkTDxInteractorStyleWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTDxStyle(
			(vtkTDxInteractorStyle *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::SetTimerDuration(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsUint32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTimerDuration(
			info[0]->Uint32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::SetUseTimers(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetUseTimers(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::Spin(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Spin();
}

void VtkInteractorStyleWrap::StartAnimate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartAnimate();
}

void VtkInteractorStyleWrap::StartDolly(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartDolly();
}

void VtkInteractorStyleWrap::StartPan(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartPan();
}

void VtkInteractorStyleWrap::StartRotate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartRotate();
}

void VtkInteractorStyleWrap::StartSpin(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartSpin();
}

void VtkInteractorStyleWrap::StartState(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->StartState(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkInteractorStyleWrap::StartTimer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartTimer();
}

void VtkInteractorStyleWrap::StartTwoPointer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartTwoPointer();
}

void VtkInteractorStyleWrap::StartUniformScale(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartUniformScale();
}

void VtkInteractorStyleWrap::StartZoom(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartZoom();
}

void VtkInteractorStyleWrap::StopAnimate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StopAnimate();
}

void VtkInteractorStyleWrap::StopState(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StopState();
}

void VtkInteractorStyleWrap::UniformScale(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UniformScale();
}

void VtkInteractorStyleWrap::UseTimersOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UseTimersOff();
}

void VtkInteractorStyleWrap::UseTimersOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UseTimersOn();
}

void VtkInteractorStyleWrap::Zoom(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkInteractorStyleWrap *wrapper = ObjectWrap::Unwrap<VtkInteractorStyleWrap>(info.Holder());
	vtkInteractorStyle *native = (vtkInteractorStyle *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Zoom();
}