/* 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 "vtkObjectWrap.h"
#include "vtkRenderWindowInteractorWrap.h"
#include "vtkRenderWindowWrap.h"
#include "vtkInteractorObserverWrap.h"
#include "vtkAbstractPickerWrap.h"
#include "vtkAbstractPropPickerWrap.h"
#include "vtkPickingManagerWrap.h"
#include "vtkRendererWrap.h"
#include "vtkObserverMediatorWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkRenderWindowInteractorWrap::VtkRenderWindowInteractorWrap()
{ }

VtkRenderWindowInteractorWrap::VtkRenderWindowInteractorWrap(vtkSmartPointer<vtkRenderWindowInteractor> _native)
{ native = _native; }

VtkRenderWindowInteractorWrap::~VtkRenderWindowInteractorWrap()
{ }

void VtkRenderWindowInteractorWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkRenderWindowInteractor").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("RenderWindowInteractor").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "CharEvent", CharEvent);
	Nan::SetPrototypeMethod(tpl, "charEvent", CharEvent);

	Nan::SetPrototypeMethod(tpl, "ClearPointerIndex", ClearPointerIndex);
	Nan::SetPrototypeMethod(tpl, "clearPointerIndex", ClearPointerIndex);

	Nan::SetPrototypeMethod(tpl, "ConfigureEvent", ConfigureEvent);
	Nan::SetPrototypeMethod(tpl, "configureEvent", ConfigureEvent);

	Nan::SetPrototypeMethod(tpl, "CreateDefaultPicker", CreateDefaultPicker);
	Nan::SetPrototypeMethod(tpl, "createDefaultPicker", CreateDefaultPicker);

	Nan::SetPrototypeMethod(tpl, "CreateOneShotTimer", CreateOneShotTimer);
	Nan::SetPrototypeMethod(tpl, "createOneShotTimer", CreateOneShotTimer);

	Nan::SetPrototypeMethod(tpl, "CreateRepeatingTimer", CreateRepeatingTimer);
	Nan::SetPrototypeMethod(tpl, "createRepeatingTimer", CreateRepeatingTimer);

	Nan::SetPrototypeMethod(tpl, "CreateTimer", CreateTimer);
	Nan::SetPrototypeMethod(tpl, "createTimer", CreateTimer);

	Nan::SetPrototypeMethod(tpl, "DestroyTimer", DestroyTimer);
	Nan::SetPrototypeMethod(tpl, "destroyTimer", DestroyTimer);

	Nan::SetPrototypeMethod(tpl, "Disable", Disable);
	Nan::SetPrototypeMethod(tpl, "disable", Disable);

	Nan::SetPrototypeMethod(tpl, "Enable", Enable);
	Nan::SetPrototypeMethod(tpl, "enable", Enable);

	Nan::SetPrototypeMethod(tpl, "EnableRenderOff", EnableRenderOff);
	Nan::SetPrototypeMethod(tpl, "enableRenderOff", EnableRenderOff);

	Nan::SetPrototypeMethod(tpl, "EnableRenderOn", EnableRenderOn);
	Nan::SetPrototypeMethod(tpl, "enableRenderOn", EnableRenderOn);

	Nan::SetPrototypeMethod(tpl, "EndPickCallback", EndPickCallback);
	Nan::SetPrototypeMethod(tpl, "endPickCallback", EndPickCallback);

	Nan::SetPrototypeMethod(tpl, "EnterEvent", EnterEvent);
	Nan::SetPrototypeMethod(tpl, "enterEvent", EnterEvent);

	Nan::SetPrototypeMethod(tpl, "ExitCallback", ExitCallback);
	Nan::SetPrototypeMethod(tpl, "exitCallback", ExitCallback);

	Nan::SetPrototypeMethod(tpl, "ExitEvent", ExitEvent);
	Nan::SetPrototypeMethod(tpl, "exitEvent", ExitEvent);

	Nan::SetPrototypeMethod(tpl, "ExposeEvent", ExposeEvent);
	Nan::SetPrototypeMethod(tpl, "exposeEvent", ExposeEvent);

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

	Nan::SetPrototypeMethod(tpl, "FlyTo", FlyTo);
	Nan::SetPrototypeMethod(tpl, "flyTo", FlyTo);

	Nan::SetPrototypeMethod(tpl, "FlyToImage", FlyToImage);
	Nan::SetPrototypeMethod(tpl, "flyToImage", FlyToImage);

	Nan::SetPrototypeMethod(tpl, "GetAltKey", GetAltKey);
	Nan::SetPrototypeMethod(tpl, "getAltKey", GetAltKey);

	Nan::SetPrototypeMethod(tpl, "GetClassName", GetClassName);
	Nan::SetPrototypeMethod(tpl, "getClassName", GetClassName);

	Nan::SetPrototypeMethod(tpl, "GetControlKey", GetControlKey);
	Nan::SetPrototypeMethod(tpl, "getControlKey", GetControlKey);

	Nan::SetPrototypeMethod(tpl, "GetDesiredUpdateRate", GetDesiredUpdateRate);
	Nan::SetPrototypeMethod(tpl, "getDesiredUpdateRate", GetDesiredUpdateRate);

	Nan::SetPrototypeMethod(tpl, "GetDesiredUpdateRateMaxValue", GetDesiredUpdateRateMaxValue);
	Nan::SetPrototypeMethod(tpl, "getDesiredUpdateRateMaxValue", GetDesiredUpdateRateMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetDesiredUpdateRateMinValue", GetDesiredUpdateRateMinValue);
	Nan::SetPrototypeMethod(tpl, "getDesiredUpdateRateMinValue", GetDesiredUpdateRateMinValue);

	Nan::SetPrototypeMethod(tpl, "GetDolly", GetDolly);
	Nan::SetPrototypeMethod(tpl, "getDolly", GetDolly);

	Nan::SetPrototypeMethod(tpl, "GetEnableRender", GetEnableRender);
	Nan::SetPrototypeMethod(tpl, "getEnableRender", GetEnableRender);

	Nan::SetPrototypeMethod(tpl, "GetEnabled", GetEnabled);
	Nan::SetPrototypeMethod(tpl, "getEnabled", GetEnabled);

	Nan::SetPrototypeMethod(tpl, "GetEventPosition", GetEventPosition);
	Nan::SetPrototypeMethod(tpl, "getEventPosition", GetEventPosition);

	Nan::SetPrototypeMethod(tpl, "GetEventSize", GetEventSize);
	Nan::SetPrototypeMethod(tpl, "getEventSize", GetEventSize);

	Nan::SetPrototypeMethod(tpl, "GetInitialized", GetInitialized);
	Nan::SetPrototypeMethod(tpl, "getInitialized", GetInitialized);

	Nan::SetPrototypeMethod(tpl, "GetInteractorStyle", GetInteractorStyle);
	Nan::SetPrototypeMethod(tpl, "getInteractorStyle", GetInteractorStyle);

	Nan::SetPrototypeMethod(tpl, "GetKeyCode", GetKeyCode);
	Nan::SetPrototypeMethod(tpl, "getKeyCode", GetKeyCode);

	Nan::SetPrototypeMethod(tpl, "GetKeySym", GetKeySym);
	Nan::SetPrototypeMethod(tpl, "getKeySym", GetKeySym);

	Nan::SetPrototypeMethod(tpl, "GetLastEventPosition", GetLastEventPosition);
	Nan::SetPrototypeMethod(tpl, "getLastEventPosition", GetLastEventPosition);

	Nan::SetPrototypeMethod(tpl, "GetLightFollowCamera", GetLightFollowCamera);
	Nan::SetPrototypeMethod(tpl, "getLightFollowCamera", GetLightFollowCamera);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfFlyFrames", GetNumberOfFlyFrames);
	Nan::SetPrototypeMethod(tpl, "getNumberOfFlyFrames", GetNumberOfFlyFrames);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfFlyFramesMaxValue", GetNumberOfFlyFramesMaxValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfFlyFramesMaxValue", GetNumberOfFlyFramesMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfFlyFramesMinValue", GetNumberOfFlyFramesMinValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfFlyFramesMinValue", GetNumberOfFlyFramesMinValue);

	Nan::SetPrototypeMethod(tpl, "GetObserverMediator", GetObserverMediator);
	Nan::SetPrototypeMethod(tpl, "getObserverMediator", GetObserverMediator);

	Nan::SetPrototypeMethod(tpl, "GetPicker", GetPicker);
	Nan::SetPrototypeMethod(tpl, "getPicker", GetPicker);

	Nan::SetPrototypeMethod(tpl, "GetPickingManager", GetPickingManager);
	Nan::SetPrototypeMethod(tpl, "getPickingManager", GetPickingManager);

	Nan::SetPrototypeMethod(tpl, "GetPointerIndex", GetPointerIndex);
	Nan::SetPrototypeMethod(tpl, "getPointerIndex", GetPointerIndex);

	Nan::SetPrototypeMethod(tpl, "GetRenderWindow", GetRenderWindow);
	Nan::SetPrototypeMethod(tpl, "getRenderWindow", GetRenderWindow);

	Nan::SetPrototypeMethod(tpl, "GetRepeatCount", GetRepeatCount);
	Nan::SetPrototypeMethod(tpl, "getRepeatCount", GetRepeatCount);

	Nan::SetPrototypeMethod(tpl, "GetShiftKey", GetShiftKey);
	Nan::SetPrototypeMethod(tpl, "getShiftKey", GetShiftKey);

	Nan::SetPrototypeMethod(tpl, "GetSize", GetSize);
	Nan::SetPrototypeMethod(tpl, "getSize", GetSize);

	Nan::SetPrototypeMethod(tpl, "GetStillUpdateRate", GetStillUpdateRate);
	Nan::SetPrototypeMethod(tpl, "getStillUpdateRate", GetStillUpdateRate);

	Nan::SetPrototypeMethod(tpl, "GetStillUpdateRateMaxValue", GetStillUpdateRateMaxValue);
	Nan::SetPrototypeMethod(tpl, "getStillUpdateRateMaxValue", GetStillUpdateRateMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetStillUpdateRateMinValue", GetStillUpdateRateMinValue);
	Nan::SetPrototypeMethod(tpl, "getStillUpdateRateMinValue", GetStillUpdateRateMinValue);

	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, "GetTimerEventDuration", GetTimerEventDuration);
	Nan::SetPrototypeMethod(tpl, "getTimerEventDuration", GetTimerEventDuration);

	Nan::SetPrototypeMethod(tpl, "GetTimerEventId", GetTimerEventId);
	Nan::SetPrototypeMethod(tpl, "getTimerEventId", GetTimerEventId);

	Nan::SetPrototypeMethod(tpl, "GetTimerEventPlatformId", GetTimerEventPlatformId);
	Nan::SetPrototypeMethod(tpl, "getTimerEventPlatformId", GetTimerEventPlatformId);

	Nan::SetPrototypeMethod(tpl, "GetTimerEventType", GetTimerEventType);
	Nan::SetPrototypeMethod(tpl, "getTimerEventType", GetTimerEventType);

	Nan::SetPrototypeMethod(tpl, "GetUseTDx", GetUseTDx);
	Nan::SetPrototypeMethod(tpl, "getUseTDx", GetUseTDx);

	Nan::SetPrototypeMethod(tpl, "GetVTKTimerId", GetVTKTimerId);
	Nan::SetPrototypeMethod(tpl, "getVTKTimerId", GetVTKTimerId);

	Nan::SetPrototypeMethod(tpl, "HideCursor", HideCursor);
	Nan::SetPrototypeMethod(tpl, "hideCursor", HideCursor);

	Nan::SetPrototypeMethod(tpl, "Initialize", Initialize);
	Nan::SetPrototypeMethod(tpl, "initialize", Initialize);

	Nan::SetPrototypeMethod(tpl, "IsA", IsA);
	Nan::SetPrototypeMethod(tpl, "isA", IsA);

	Nan::SetPrototypeMethod(tpl, "IsOneShotTimer", IsOneShotTimer);
	Nan::SetPrototypeMethod(tpl, "isOneShotTimer", IsOneShotTimer);

	Nan::SetPrototypeMethod(tpl, "IsPointerIndexSet", IsPointerIndexSet);
	Nan::SetPrototypeMethod(tpl, "isPointerIndexSet", IsPointerIndexSet);

	Nan::SetPrototypeMethod(tpl, "KeyPressEvent", KeyPressEvent);
	Nan::SetPrototypeMethod(tpl, "keyPressEvent", KeyPressEvent);

	Nan::SetPrototypeMethod(tpl, "KeyReleaseEvent", KeyReleaseEvent);
	Nan::SetPrototypeMethod(tpl, "keyReleaseEvent", KeyReleaseEvent);

	Nan::SetPrototypeMethod(tpl, "LeaveEvent", LeaveEvent);
	Nan::SetPrototypeMethod(tpl, "leaveEvent", LeaveEvent);

	Nan::SetPrototypeMethod(tpl, "LeftButtonPressEvent", LeftButtonPressEvent);
	Nan::SetPrototypeMethod(tpl, "leftButtonPressEvent", LeftButtonPressEvent);

	Nan::SetPrototypeMethod(tpl, "LeftButtonReleaseEvent", LeftButtonReleaseEvent);
	Nan::SetPrototypeMethod(tpl, "leftButtonReleaseEvent", LeftButtonReleaseEvent);

	Nan::SetPrototypeMethod(tpl, "LightFollowCameraOff", LightFollowCameraOff);
	Nan::SetPrototypeMethod(tpl, "lightFollowCameraOff", LightFollowCameraOff);

	Nan::SetPrototypeMethod(tpl, "LightFollowCameraOn", LightFollowCameraOn);
	Nan::SetPrototypeMethod(tpl, "lightFollowCameraOn", LightFollowCameraOn);

	Nan::SetPrototypeMethod(tpl, "MiddleButtonPressEvent", MiddleButtonPressEvent);
	Nan::SetPrototypeMethod(tpl, "middleButtonPressEvent", MiddleButtonPressEvent);

	Nan::SetPrototypeMethod(tpl, "MiddleButtonReleaseEvent", MiddleButtonReleaseEvent);
	Nan::SetPrototypeMethod(tpl, "middleButtonReleaseEvent", MiddleButtonReleaseEvent);

	Nan::SetPrototypeMethod(tpl, "MouseMoveEvent", MouseMoveEvent);
	Nan::SetPrototypeMethod(tpl, "mouseMoveEvent", MouseMoveEvent);

	Nan::SetPrototypeMethod(tpl, "MouseWheelBackwardEvent", MouseWheelBackwardEvent);
	Nan::SetPrototypeMethod(tpl, "mouseWheelBackwardEvent", MouseWheelBackwardEvent);

	Nan::SetPrototypeMethod(tpl, "MouseWheelForwardEvent", MouseWheelForwardEvent);
	Nan::SetPrototypeMethod(tpl, "mouseWheelForwardEvent", MouseWheelForwardEvent);

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

	Nan::SetPrototypeMethod(tpl, "ReInitialize", ReInitialize);
	Nan::SetPrototypeMethod(tpl, "reInitialize", ReInitialize);

	Nan::SetPrototypeMethod(tpl, "Render", Render);
	Nan::SetPrototypeMethod(tpl, "render", Render);

	Nan::SetPrototypeMethod(tpl, "ResetTimer", ResetTimer);
	Nan::SetPrototypeMethod(tpl, "resetTimer", ResetTimer);

	Nan::SetPrototypeMethod(tpl, "RightButtonPressEvent", RightButtonPressEvent);
	Nan::SetPrototypeMethod(tpl, "rightButtonPressEvent", RightButtonPressEvent);

	Nan::SetPrototypeMethod(tpl, "RightButtonReleaseEvent", RightButtonReleaseEvent);
	Nan::SetPrototypeMethod(tpl, "rightButtonReleaseEvent", RightButtonReleaseEvent);

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

	Nan::SetPrototypeMethod(tpl, "SetAltKey", SetAltKey);
	Nan::SetPrototypeMethod(tpl, "setAltKey", SetAltKey);

	Nan::SetPrototypeMethod(tpl, "SetControlKey", SetControlKey);
	Nan::SetPrototypeMethod(tpl, "setControlKey", SetControlKey);

	Nan::SetPrototypeMethod(tpl, "SetDesiredUpdateRate", SetDesiredUpdateRate);
	Nan::SetPrototypeMethod(tpl, "setDesiredUpdateRate", SetDesiredUpdateRate);

	Nan::SetPrototypeMethod(tpl, "SetDolly", SetDolly);
	Nan::SetPrototypeMethod(tpl, "setDolly", SetDolly);

	Nan::SetPrototypeMethod(tpl, "SetEnableRender", SetEnableRender);
	Nan::SetPrototypeMethod(tpl, "setEnableRender", SetEnableRender);

	Nan::SetPrototypeMethod(tpl, "SetEventInformation", SetEventInformation);
	Nan::SetPrototypeMethod(tpl, "setEventInformation", SetEventInformation);

	Nan::SetPrototypeMethod(tpl, "SetEventInformationFlipY", SetEventInformationFlipY);
	Nan::SetPrototypeMethod(tpl, "setEventInformationFlipY", SetEventInformationFlipY);

	Nan::SetPrototypeMethod(tpl, "SetEventPosition", SetEventPosition);
	Nan::SetPrototypeMethod(tpl, "setEventPosition", SetEventPosition);

	Nan::SetPrototypeMethod(tpl, "SetEventPositionFlipY", SetEventPositionFlipY);
	Nan::SetPrototypeMethod(tpl, "setEventPositionFlipY", SetEventPositionFlipY);

	Nan::SetPrototypeMethod(tpl, "SetEventSize", SetEventSize);
	Nan::SetPrototypeMethod(tpl, "setEventSize", SetEventSize);

	Nan::SetPrototypeMethod(tpl, "SetInteractorStyle", SetInteractorStyle);
	Nan::SetPrototypeMethod(tpl, "setInteractorStyle", SetInteractorStyle);

	Nan::SetPrototypeMethod(tpl, "SetKeyCode", SetKeyCode);
	Nan::SetPrototypeMethod(tpl, "setKeyCode", SetKeyCode);

	Nan::SetPrototypeMethod(tpl, "SetKeyEventInformation", SetKeyEventInformation);
	Nan::SetPrototypeMethod(tpl, "setKeyEventInformation", SetKeyEventInformation);

	Nan::SetPrototypeMethod(tpl, "SetKeySym", SetKeySym);
	Nan::SetPrototypeMethod(tpl, "setKeySym", SetKeySym);

	Nan::SetPrototypeMethod(tpl, "SetLastEventPosition", SetLastEventPosition);
	Nan::SetPrototypeMethod(tpl, "setLastEventPosition", SetLastEventPosition);

	Nan::SetPrototypeMethod(tpl, "SetLightFollowCamera", SetLightFollowCamera);
	Nan::SetPrototypeMethod(tpl, "setLightFollowCamera", SetLightFollowCamera);

	Nan::SetPrototypeMethod(tpl, "SetNumberOfFlyFrames", SetNumberOfFlyFrames);
	Nan::SetPrototypeMethod(tpl, "setNumberOfFlyFrames", SetNumberOfFlyFrames);

	Nan::SetPrototypeMethod(tpl, "SetPicker", SetPicker);
	Nan::SetPrototypeMethod(tpl, "setPicker", SetPicker);

	Nan::SetPrototypeMethod(tpl, "SetPickingManager", SetPickingManager);
	Nan::SetPrototypeMethod(tpl, "setPickingManager", SetPickingManager);

	Nan::SetPrototypeMethod(tpl, "SetPointerIndex", SetPointerIndex);
	Nan::SetPrototypeMethod(tpl, "setPointerIndex", SetPointerIndex);

	Nan::SetPrototypeMethod(tpl, "SetRenderWindow", SetRenderWindow);
	Nan::SetPrototypeMethod(tpl, "setRenderWindow", SetRenderWindow);

	Nan::SetPrototypeMethod(tpl, "SetRepeatCount", SetRepeatCount);
	Nan::SetPrototypeMethod(tpl, "setRepeatCount", SetRepeatCount);

	Nan::SetPrototypeMethod(tpl, "SetShiftKey", SetShiftKey);
	Nan::SetPrototypeMethod(tpl, "setShiftKey", SetShiftKey);

	Nan::SetPrototypeMethod(tpl, "SetSize", SetSize);
	Nan::SetPrototypeMethod(tpl, "setSize", SetSize);

	Nan::SetPrototypeMethod(tpl, "SetStillUpdateRate", SetStillUpdateRate);
	Nan::SetPrototypeMethod(tpl, "setStillUpdateRate", SetStillUpdateRate);

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

	Nan::SetPrototypeMethod(tpl, "SetTimerEventDuration", SetTimerEventDuration);
	Nan::SetPrototypeMethod(tpl, "setTimerEventDuration", SetTimerEventDuration);

	Nan::SetPrototypeMethod(tpl, "SetTimerEventId", SetTimerEventId);
	Nan::SetPrototypeMethod(tpl, "setTimerEventId", SetTimerEventId);

	Nan::SetPrototypeMethod(tpl, "SetTimerEventPlatformId", SetTimerEventPlatformId);
	Nan::SetPrototypeMethod(tpl, "setTimerEventPlatformId", SetTimerEventPlatformId);

	Nan::SetPrototypeMethod(tpl, "SetTimerEventType", SetTimerEventType);
	Nan::SetPrototypeMethod(tpl, "setTimerEventType", SetTimerEventType);

	Nan::SetPrototypeMethod(tpl, "SetUseTDx", SetUseTDx);
	Nan::SetPrototypeMethod(tpl, "setUseTDx", SetUseTDx);

	Nan::SetPrototypeMethod(tpl, "ShowCursor", ShowCursor);
	Nan::SetPrototypeMethod(tpl, "showCursor", ShowCursor);

	Nan::SetPrototypeMethod(tpl, "Start", Start);
	Nan::SetPrototypeMethod(tpl, "start", Start);

	Nan::SetPrototypeMethod(tpl, "StartPickCallback", StartPickCallback);
	Nan::SetPrototypeMethod(tpl, "startPickCallback", StartPickCallback);

	Nan::SetPrototypeMethod(tpl, "TerminateApp", TerminateApp);
	Nan::SetPrototypeMethod(tpl, "terminateApp", TerminateApp);

	Nan::SetPrototypeMethod(tpl, "UpdateSize", UpdateSize);
	Nan::SetPrototypeMethod(tpl, "updateSize", UpdateSize);

	Nan::SetPrototypeMethod(tpl, "UserCallback", UserCallback);
	Nan::SetPrototypeMethod(tpl, "userCallback", UserCallback);

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

void VtkRenderWindowInteractorWrap::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<vtkRenderWindowInteractor> native = vtkSmartPointer<vtkRenderWindowInteractor>::New();
		VtkRenderWindowInteractorWrap* obj = new VtkRenderWindowInteractorWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

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

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

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

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

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

void VtkRenderWindowInteractorWrap::CreateOneShotTimer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsUint32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->CreateOneShotTimer(
			info[0]->Uint32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderWindowInteractorWrap::CreateRepeatingTimer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsUint32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->CreateRepeatingTimer(
			info[0]->Uint32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderWindowInteractorWrap::CreateTimer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->CreateTimer(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderWindowInteractorWrap::DestroyTimer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->DestroyTimer(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->DestroyTimer();
	info.GetReturnValue().Set(Nan::New(r));
}

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

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

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

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

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

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

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

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

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

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

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

void VtkRenderWindowInteractorWrap::FlyToImage(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkRendererWrap::ptpl))->HasInstance(info[0]))
	{
		VtkRendererWrap *a0 = ObjectWrap::Unwrap<VtkRendererWrap>(info[0]->ToObject());
		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->FlyToImage(
					(vtkRenderer *) a0->native.GetPointer(),
					info[1]->NumberValue(),
					info[2]->NumberValue()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkRenderWindowInteractorWrap::GetTimerDurationMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)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 VtkRenderWindowInteractorWrap::GetTimerDurationMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)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 VtkRenderWindowInteractorWrap::GetTimerEventDuration(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTimerEventDuration();
	info.GetReturnValue().Set(Nan::New(r));
}

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

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

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

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

void VtkRenderWindowInteractorWrap::GetVTKTimerId(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetVTKTimerId(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

void VtkRenderWindowInteractorWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->IsA(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderWindowInteractorWrap::IsOneShotTimer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->IsOneShotTimer(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderWindowInteractorWrap::IsPointerIndexSet(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		bool r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->IsPointerIndexSet(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkRenderWindowInteractorWrap::ResetTimer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->ResetTimer(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

void VtkRenderWindowInteractorWrap::SetEventInformation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				if(info.Length() > 3 && info[3]->IsInt32())
				{
					if(info.Length() > 4 && info[4]->IsInt32())
					{
						char a4 = info[4]->Int32Value();
						if( a4 < -127 || a4 > 128 )
						{
							Nan::ThrowError("char value out of bounds.");
							return;
						}
						if(info.Length() > 5 && info[5]->IsInt32())
						{
							if(info.Length() > 6 && info[6]->IsString())
							{
								Nan::Utf8String a6(info[6]);
								if(info.Length() > 7 && info[7]->IsInt32())
								{
																		if(info.Length() != 8)
									{
										Nan::ThrowError("Too many parameters.");
										return;
									}
									native->SetEventInformation(
										info[0]->Int32Value(),
										info[1]->Int32Value(),
										info[2]->Int32Value(),
										info[3]->Int32Value(),
										a4,
										info[5]->Int32Value(),
										*a6,
										info[7]->Int32Value()
									);
									return;
								}
																if(info.Length() != 7)
								{
									Nan::ThrowError("Too many parameters.");
									return;
								}
								native->SetEventInformation(
									info[0]->Int32Value(),
									info[1]->Int32Value(),
									info[2]->Int32Value(),
									info[3]->Int32Value(),
									a4,
									info[5]->Int32Value(),
									*a6
								);
								return;
							}
						}
					}
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderWindowInteractorWrap::SetEventInformationFlipY(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				if(info.Length() > 3 && info[3]->IsInt32())
				{
					if(info.Length() > 4 && info[4]->IsInt32())
					{
						char a4 = info[4]->Int32Value();
						if( a4 < -127 || a4 > 128 )
						{
							Nan::ThrowError("char value out of bounds.");
							return;
						}
						if(info.Length() > 5 && info[5]->IsInt32())
						{
							if(info.Length() > 6 && info[6]->IsString())
							{
								Nan::Utf8String a6(info[6]);
								if(info.Length() > 7 && info[7]->IsInt32())
								{
																		if(info.Length() != 8)
									{
										Nan::ThrowError("Too many parameters.");
										return;
									}
									native->SetEventInformationFlipY(
										info[0]->Int32Value(),
										info[1]->Int32Value(),
										info[2]->Int32Value(),
										info[3]->Int32Value(),
										a4,
										info[5]->Int32Value(),
										*a6,
										info[7]->Int32Value()
									);
									return;
								}
																if(info.Length() != 7)
								{
									Nan::ThrowError("Too many parameters.");
									return;
								}
								native->SetEventInformationFlipY(
									info[0]->Int32Value(),
									info[1]->Int32Value(),
									info[2]->Int32Value(),
									info[3]->Int32Value(),
									a4,
									info[5]->Int32Value(),
									*a6
								);
								return;
							}
						}
					}
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderWindowInteractorWrap::SetEventPosition(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsInt32Array())
	{
		v8::Local<v8::Int32Array>a0(v8::Local<v8::Int32Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

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

		for( i = 0; i < 2; i++ )
		{
			if( !a0->Get(i)->IsInt32() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->Int32Value();
		}
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetEventPosition(
				b0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsInt32Array())
	{
		v8::Local<v8::Int32Array>a0(v8::Local<v8::Int32Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEventPosition(
			(int *)(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()));
		int b0[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

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

void VtkRenderWindowInteractorWrap::SetEventPositionFlipY(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsInt32Array())
	{
		v8::Local<v8::Int32Array>a0(v8::Local<v8::Int32Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

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

		for( i = 0; i < 2; i++ )
		{
			if( !a0->Get(i)->IsInt32() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->Int32Value();
		}
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetEventPositionFlipY(
				b0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsInt32Array())
	{
		v8::Local<v8::Int32Array>a0(v8::Local<v8::Int32Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEventPositionFlipY(
			(int *)(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()));
		int b0[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

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

void VtkRenderWindowInteractorWrap::SetEventSize(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsInt32Array())
	{
		v8::Local<v8::Int32Array>a0(v8::Local<v8::Int32Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEventSize(
			(int *)(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()));
		int b0[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; i++ )
		{
			if( !a0->Get(i)->IsInt32() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->Int32Value();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEventSize(
			b0
		);
		return;
	}
	else 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->SetEventSize(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

void VtkRenderWindowInteractorWrap::SetKeyCode(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char a0 = info[0]->Int32Value();
		if( a0 < -127 || a0 > 128 )
		{
			Nan::ThrowError("char value out of bounds.");
			return;
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyCode(
			a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkRenderWindowInteractorWrap::SetKeyEventInformation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				char a2 = info[2]->Int32Value();
				if( a2 < -127 || a2 > 128 )
				{
					Nan::ThrowError("char value out of bounds.");
					return;
				}
				if(info.Length() > 3 && info[3]->IsInt32())
				{
					if(info.Length() > 4 && info[4]->IsString())
					{
						Nan::Utf8String a4(info[4]);
												if(info.Length() != 5)
						{
							Nan::ThrowError("Too many parameters.");
							return;
						}
						native->SetKeyEventInformation(
							info[0]->Int32Value(),
							info[1]->Int32Value(),
							a2,
							info[3]->Int32Value(),
							*a4
						);
						return;
					}
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

void VtkRenderWindowInteractorWrap::SetLastEventPosition(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsInt32Array())
	{
		v8::Local<v8::Int32Array>a0(v8::Local<v8::Int32Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLastEventPosition(
			(int *)(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()));
		int b0[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; i++ )
		{
			if( !a0->Get(i)->IsInt32() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->Int32Value();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLastEventPosition(
			b0
		);
		return;
	}
	else 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->SetLastEventPosition(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

void VtkRenderWindowInteractorWrap::SetSize(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsInt32Array())
	{
		v8::Local<v8::Int32Array>a0(v8::Local<v8::Int32Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSize(
			(int *)(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()));
		int b0[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; i++ )
		{
			if( !a0->Get(i)->IsInt32() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->Int32Value();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSize(
			b0
		);
		return;
	}
	else 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->SetSize(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

void VtkRenderWindowInteractorWrap::SetTimerDuration(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)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 VtkRenderWindowInteractorWrap::SetTimerEventDuration(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTimerEventDuration(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

void VtkRenderWindowInteractorWrap::UpdateSize(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRenderWindowInteractorWrap *wrapper = ObjectWrap::Unwrap<VtkRenderWindowInteractorWrap>(info.Holder());
	vtkRenderWindowInteractor *native = (vtkRenderWindowInteractor *)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->UpdateSize(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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