/* 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 "vtkActor2DWrap.h"
#include "vtkCubeAxesActor2DWrap.h"
#include "vtkObjectWrap.h"
#include "vtkViewportWrap.h"
#include "vtkAlgorithmOutputWrap.h"
#include "vtkDataSetWrap.h"
#include "vtkPropWrap.h"
#include "vtkCameraWrap.h"
#include "vtkAxisActor2DWrap.h"
#include "vtkTextPropertyWrap.h"
#include "vtkWindowWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkCubeAxesActor2DWrap::VtkCubeAxesActor2DWrap()
{ }

VtkCubeAxesActor2DWrap::VtkCubeAxesActor2DWrap(vtkSmartPointer<vtkCubeAxesActor2D> _native)
{ native = _native; }

VtkCubeAxesActor2DWrap::~VtkCubeAxesActor2DWrap()
{ }

void VtkCubeAxesActor2DWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkCubeAxesActor2D").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("CubeAxesActor2D").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "GetAxisLabelTextProperty", GetAxisLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "getAxisLabelTextProperty", GetAxisLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetAxisTitleTextProperty", GetAxisTitleTextProperty);
	Nan::SetPrototypeMethod(tpl, "getAxisTitleTextProperty", GetAxisTitleTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetBounds", GetBounds);
	Nan::SetPrototypeMethod(tpl, "getBounds", GetBounds);

	Nan::SetPrototypeMethod(tpl, "GetCamera", GetCamera);
	Nan::SetPrototypeMethod(tpl, "getCamera", GetCamera);

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

	Nan::SetPrototypeMethod(tpl, "GetCornerOffset", GetCornerOffset);
	Nan::SetPrototypeMethod(tpl, "getCornerOffset", GetCornerOffset);

	Nan::SetPrototypeMethod(tpl, "GetFlyMode", GetFlyMode);
	Nan::SetPrototypeMethod(tpl, "getFlyMode", GetFlyMode);

	Nan::SetPrototypeMethod(tpl, "GetFlyModeMaxValue", GetFlyModeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getFlyModeMaxValue", GetFlyModeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetFlyModeMinValue", GetFlyModeMinValue);
	Nan::SetPrototypeMethod(tpl, "getFlyModeMinValue", GetFlyModeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetFontFactor", GetFontFactor);
	Nan::SetPrototypeMethod(tpl, "getFontFactor", GetFontFactor);

	Nan::SetPrototypeMethod(tpl, "GetFontFactorMaxValue", GetFontFactorMaxValue);
	Nan::SetPrototypeMethod(tpl, "getFontFactorMaxValue", GetFontFactorMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetFontFactorMinValue", GetFontFactorMinValue);
	Nan::SetPrototypeMethod(tpl, "getFontFactorMinValue", GetFontFactorMinValue);

	Nan::SetPrototypeMethod(tpl, "GetInertia", GetInertia);
	Nan::SetPrototypeMethod(tpl, "getInertia", GetInertia);

	Nan::SetPrototypeMethod(tpl, "GetInertiaMaxValue", GetInertiaMaxValue);
	Nan::SetPrototypeMethod(tpl, "getInertiaMaxValue", GetInertiaMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetInertiaMinValue", GetInertiaMinValue);
	Nan::SetPrototypeMethod(tpl, "getInertiaMinValue", GetInertiaMinValue);

	Nan::SetPrototypeMethod(tpl, "GetInput", GetInput);
	Nan::SetPrototypeMethod(tpl, "getInput", GetInput);

	Nan::SetPrototypeMethod(tpl, "GetLabelFormat", GetLabelFormat);
	Nan::SetPrototypeMethod(tpl, "getLabelFormat", GetLabelFormat);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfLabels", GetNumberOfLabels);
	Nan::SetPrototypeMethod(tpl, "getNumberOfLabels", GetNumberOfLabels);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfLabelsMaxValue", GetNumberOfLabelsMaxValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfLabelsMaxValue", GetNumberOfLabelsMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfLabelsMinValue", GetNumberOfLabelsMinValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfLabelsMinValue", GetNumberOfLabelsMinValue);

	Nan::SetPrototypeMethod(tpl, "GetRanges", GetRanges);
	Nan::SetPrototypeMethod(tpl, "getRanges", GetRanges);

	Nan::SetPrototypeMethod(tpl, "GetScaling", GetScaling);
	Nan::SetPrototypeMethod(tpl, "getScaling", GetScaling);

	Nan::SetPrototypeMethod(tpl, "GetShowActualBounds", GetShowActualBounds);
	Nan::SetPrototypeMethod(tpl, "getShowActualBounds", GetShowActualBounds);

	Nan::SetPrototypeMethod(tpl, "GetShowActualBoundsMaxValue", GetShowActualBoundsMaxValue);
	Nan::SetPrototypeMethod(tpl, "getShowActualBoundsMaxValue", GetShowActualBoundsMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetShowActualBoundsMinValue", GetShowActualBoundsMinValue);
	Nan::SetPrototypeMethod(tpl, "getShowActualBoundsMinValue", GetShowActualBoundsMinValue);

	Nan::SetPrototypeMethod(tpl, "GetUseRanges", GetUseRanges);
	Nan::SetPrototypeMethod(tpl, "getUseRanges", GetUseRanges);

	Nan::SetPrototypeMethod(tpl, "GetViewProp", GetViewProp);
	Nan::SetPrototypeMethod(tpl, "getViewProp", GetViewProp);

	Nan::SetPrototypeMethod(tpl, "GetXAxisActor2D", GetXAxisActor2D);
	Nan::SetPrototypeMethod(tpl, "getXAxisActor2D", GetXAxisActor2D);

	Nan::SetPrototypeMethod(tpl, "GetXAxisVisibility", GetXAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getXAxisVisibility", GetXAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "GetXLabel", GetXLabel);
	Nan::SetPrototypeMethod(tpl, "getXLabel", GetXLabel);

	Nan::SetPrototypeMethod(tpl, "GetYAxisActor2D", GetYAxisActor2D);
	Nan::SetPrototypeMethod(tpl, "getYAxisActor2D", GetYAxisActor2D);

	Nan::SetPrototypeMethod(tpl, "GetYAxisVisibility", GetYAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getYAxisVisibility", GetYAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "GetYLabel", GetYLabel);
	Nan::SetPrototypeMethod(tpl, "getYLabel", GetYLabel);

	Nan::SetPrototypeMethod(tpl, "GetZAxisActor2D", GetZAxisActor2D);
	Nan::SetPrototypeMethod(tpl, "getZAxisActor2D", GetZAxisActor2D);

	Nan::SetPrototypeMethod(tpl, "GetZAxisVisibility", GetZAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getZAxisVisibility", GetZAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "GetZLabel", GetZLabel);
	Nan::SetPrototypeMethod(tpl, "getZLabel", GetZLabel);

	Nan::SetPrototypeMethod(tpl, "HasTranslucentPolygonalGeometry", HasTranslucentPolygonalGeometry);
	Nan::SetPrototypeMethod(tpl, "hasTranslucentPolygonalGeometry", HasTranslucentPolygonalGeometry);

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

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

	Nan::SetPrototypeMethod(tpl, "ReleaseGraphicsResources", ReleaseGraphicsResources);
	Nan::SetPrototypeMethod(tpl, "releaseGraphicsResources", ReleaseGraphicsResources);

	Nan::SetPrototypeMethod(tpl, "RenderOpaqueGeometry", RenderOpaqueGeometry);
	Nan::SetPrototypeMethod(tpl, "renderOpaqueGeometry", RenderOpaqueGeometry);

	Nan::SetPrototypeMethod(tpl, "RenderOverlay", RenderOverlay);
	Nan::SetPrototypeMethod(tpl, "renderOverlay", RenderOverlay);

	Nan::SetPrototypeMethod(tpl, "RenderTranslucentPolygonalGeometry", RenderTranslucentPolygonalGeometry);
	Nan::SetPrototypeMethod(tpl, "renderTranslucentPolygonalGeometry", RenderTranslucentPolygonalGeometry);

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

	Nan::SetPrototypeMethod(tpl, "ScalingOff", ScalingOff);
	Nan::SetPrototypeMethod(tpl, "scalingOff", ScalingOff);

	Nan::SetPrototypeMethod(tpl, "ScalingOn", ScalingOn);
	Nan::SetPrototypeMethod(tpl, "scalingOn", ScalingOn);

	Nan::SetPrototypeMethod(tpl, "SetAxisLabelTextProperty", SetAxisLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "setAxisLabelTextProperty", SetAxisLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetAxisTitleTextProperty", SetAxisTitleTextProperty);
	Nan::SetPrototypeMethod(tpl, "setAxisTitleTextProperty", SetAxisTitleTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetBounds", SetBounds);
	Nan::SetPrototypeMethod(tpl, "setBounds", SetBounds);

	Nan::SetPrototypeMethod(tpl, "SetCamera", SetCamera);
	Nan::SetPrototypeMethod(tpl, "setCamera", SetCamera);

	Nan::SetPrototypeMethod(tpl, "SetCornerOffset", SetCornerOffset);
	Nan::SetPrototypeMethod(tpl, "setCornerOffset", SetCornerOffset);

	Nan::SetPrototypeMethod(tpl, "SetFlyMode", SetFlyMode);
	Nan::SetPrototypeMethod(tpl, "setFlyMode", SetFlyMode);

	Nan::SetPrototypeMethod(tpl, "SetFlyModeToClosestTriad", SetFlyModeToClosestTriad);
	Nan::SetPrototypeMethod(tpl, "setFlyModeToClosestTriad", SetFlyModeToClosestTriad);

	Nan::SetPrototypeMethod(tpl, "SetFlyModeToNone", SetFlyModeToNone);
	Nan::SetPrototypeMethod(tpl, "setFlyModeToNone", SetFlyModeToNone);

	Nan::SetPrototypeMethod(tpl, "SetFlyModeToOuterEdges", SetFlyModeToOuterEdges);
	Nan::SetPrototypeMethod(tpl, "setFlyModeToOuterEdges", SetFlyModeToOuterEdges);

	Nan::SetPrototypeMethod(tpl, "SetFontFactor", SetFontFactor);
	Nan::SetPrototypeMethod(tpl, "setFontFactor", SetFontFactor);

	Nan::SetPrototypeMethod(tpl, "SetInertia", SetInertia);
	Nan::SetPrototypeMethod(tpl, "setInertia", SetInertia);

	Nan::SetPrototypeMethod(tpl, "SetInputConnection", SetInputConnection);
	Nan::SetPrototypeMethod(tpl, "setInputConnection", SetInputConnection);

	Nan::SetPrototypeMethod(tpl, "SetInputData", SetInputData);
	Nan::SetPrototypeMethod(tpl, "setInputData", SetInputData);

	Nan::SetPrototypeMethod(tpl, "SetLabelFormat", SetLabelFormat);
	Nan::SetPrototypeMethod(tpl, "setLabelFormat", SetLabelFormat);

	Nan::SetPrototypeMethod(tpl, "SetNumberOfLabels", SetNumberOfLabels);
	Nan::SetPrototypeMethod(tpl, "setNumberOfLabels", SetNumberOfLabels);

	Nan::SetPrototypeMethod(tpl, "SetRanges", SetRanges);
	Nan::SetPrototypeMethod(tpl, "setRanges", SetRanges);

	Nan::SetPrototypeMethod(tpl, "SetScaling", SetScaling);
	Nan::SetPrototypeMethod(tpl, "setScaling", SetScaling);

	Nan::SetPrototypeMethod(tpl, "SetShowActualBounds", SetShowActualBounds);
	Nan::SetPrototypeMethod(tpl, "setShowActualBounds", SetShowActualBounds);

	Nan::SetPrototypeMethod(tpl, "SetUseRanges", SetUseRanges);
	Nan::SetPrototypeMethod(tpl, "setUseRanges", SetUseRanges);

	Nan::SetPrototypeMethod(tpl, "SetViewProp", SetViewProp);
	Nan::SetPrototypeMethod(tpl, "setViewProp", SetViewProp);

	Nan::SetPrototypeMethod(tpl, "SetXAxisVisibility", SetXAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setXAxisVisibility", SetXAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "SetXLabel", SetXLabel);
	Nan::SetPrototypeMethod(tpl, "setXLabel", SetXLabel);

	Nan::SetPrototypeMethod(tpl, "SetXOrigin", SetXOrigin);
	Nan::SetPrototypeMethod(tpl, "setXOrigin", SetXOrigin);

	Nan::SetPrototypeMethod(tpl, "SetYAxisVisibility", SetYAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setYAxisVisibility", SetYAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "SetYLabel", SetYLabel);
	Nan::SetPrototypeMethod(tpl, "setYLabel", SetYLabel);

	Nan::SetPrototypeMethod(tpl, "SetYOrigin", SetYOrigin);
	Nan::SetPrototypeMethod(tpl, "setYOrigin", SetYOrigin);

	Nan::SetPrototypeMethod(tpl, "SetZAxisVisibility", SetZAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setZAxisVisibility", SetZAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "SetZLabel", SetZLabel);
	Nan::SetPrototypeMethod(tpl, "setZLabel", SetZLabel);

	Nan::SetPrototypeMethod(tpl, "SetZOrigin", SetZOrigin);
	Nan::SetPrototypeMethod(tpl, "setZOrigin", SetZOrigin);

	Nan::SetPrototypeMethod(tpl, "ShallowCopy", ShallowCopy);
	Nan::SetPrototypeMethod(tpl, "shallowCopy", ShallowCopy);

	Nan::SetPrototypeMethod(tpl, "UseRangesOff", UseRangesOff);
	Nan::SetPrototypeMethod(tpl, "useRangesOff", UseRangesOff);

	Nan::SetPrototypeMethod(tpl, "UseRangesOn", UseRangesOn);
	Nan::SetPrototypeMethod(tpl, "useRangesOn", UseRangesOn);

	Nan::SetPrototypeMethod(tpl, "XAxisVisibilityOff", XAxisVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "xAxisVisibilityOff", XAxisVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "XAxisVisibilityOn", XAxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "xAxisVisibilityOn", XAxisVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "YAxisVisibilityOff", YAxisVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "yAxisVisibilityOff", YAxisVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "YAxisVisibilityOn", YAxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "yAxisVisibilityOn", YAxisVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "ZAxisVisibilityOff", ZAxisVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "zAxisVisibilityOff", ZAxisVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "ZAxisVisibilityOn", ZAxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "zAxisVisibilityOn", ZAxisVisibilityOn);

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

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

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

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

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

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

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

		for( i = 0; i < 6; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetBounds(
			b0
		);
		return;
	}
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetBounds();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 6 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 6);
	memcpy(ab->GetContents().Data(), r, 6 * sizeof(double));
	info.GetReturnValue().Set(at);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		for( i = 0; i < 6; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetRanges(
			b0
		);
		return;
	}
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRanges();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 6 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 6);
	memcpy(ab->GetContents().Data(), r, 6 * sizeof(double));
	info.GetReturnValue().Set(at);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkCubeAxesActor2DWrap::RenderOpaqueGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkCubeAxesActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkCubeAxesActor2DWrap>(info.Holder());
	vtkCubeAxesActor2D *native = (vtkCubeAxesActor2D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[0]))
	{
		VtkViewportWrap *a0 = ObjectWrap::Unwrap<VtkViewportWrap>(info[0]->ToObject());
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->RenderOpaqueGeometry(
			(vtkViewport *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkCubeAxesActor2DWrap::RenderOverlay(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkCubeAxesActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkCubeAxesActor2DWrap>(info.Holder());
	vtkCubeAxesActor2D *native = (vtkCubeAxesActor2D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[0]))
	{
		VtkViewportWrap *a0 = ObjectWrap::Unwrap<VtkViewportWrap>(info[0]->ToObject());
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->RenderOverlay(
			(vtkViewport *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkCubeAxesActor2DWrap::RenderTranslucentPolygonalGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkCubeAxesActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkCubeAxesActor2DWrap>(info.Holder());
	vtkCubeAxesActor2D *native = (vtkCubeAxesActor2D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[0]))
	{
		VtkViewportWrap *a0 = ObjectWrap::Unwrap<VtkViewportWrap>(info[0]->ToObject());
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->RenderTranslucentPolygonalGeometry(
			(vtkViewport *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkCubeAxesActor2DWrap::SetLabelFormat(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkCubeAxesActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkCubeAxesActor2DWrap>(info.Holder());
	vtkCubeAxesActor2D *native = (vtkCubeAxesActor2D *)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->SetLabelFormat(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

void VtkCubeAxesActor2DWrap::SetXLabel(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkCubeAxesActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkCubeAxesActor2DWrap>(info.Holder());
	vtkCubeAxesActor2D *native = (vtkCubeAxesActor2D *)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->SetXLabel(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

void VtkCubeAxesActor2DWrap::SetYLabel(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkCubeAxesActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkCubeAxesActor2DWrap>(info.Holder());
	vtkCubeAxesActor2D *native = (vtkCubeAxesActor2D *)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->SetYLabel(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

void VtkCubeAxesActor2DWrap::SetZLabel(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkCubeAxesActor2DWrap *wrapper = ObjectWrap::Unwrap<VtkCubeAxesActor2DWrap>(info.Holder());
	vtkCubeAxesActor2D *native = (vtkCubeAxesActor2D *)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->SetZLabel(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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