/* 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 "vtkActorWrap.h"
#include "vtkAxisActorWrap.h"
#include "vtkObjectWrap.h"
#include "vtkCoordinateWrap.h"
#include "vtkTextPropertyWrap.h"
#include "vtkPropertyWrap.h"
#include "vtkCameraWrap.h"
#include "vtkViewportWrap.h"
#include "vtkWindowWrap.h"
#include "vtkStringArrayWrap.h"
#include "vtkAxisFollowerWrap.h"
#include "vtkProp3DAxisFollowerWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkAxisActorWrap::VtkAxisActorWrap()
{ }

VtkAxisActorWrap::VtkAxisActorWrap(vtkSmartPointer<vtkAxisActor> _native)
{ native = _native; }

VtkAxisActorWrap::~VtkAxisActorWrap()
{ }

void VtkAxisActorWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkAxisActor").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("AxisActor").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "AxisVisibilityOff", AxisVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "axisVisibilityOff", AxisVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "AxisVisibilityOn", AxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "axisVisibilityOn", AxisVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "BuildAxis", BuildAxis);
	Nan::SetPrototypeMethod(tpl, "buildAxis", BuildAxis);

	Nan::SetPrototypeMethod(tpl, "CalculateLabelOffsetOff", CalculateLabelOffsetOff);
	Nan::SetPrototypeMethod(tpl, "calculateLabelOffsetOff", CalculateLabelOffsetOff);

	Nan::SetPrototypeMethod(tpl, "CalculateLabelOffsetOn", CalculateLabelOffsetOn);
	Nan::SetPrototypeMethod(tpl, "calculateLabelOffsetOn", CalculateLabelOffsetOn);

	Nan::SetPrototypeMethod(tpl, "CalculateTitleOffsetOff", CalculateTitleOffsetOff);
	Nan::SetPrototypeMethod(tpl, "calculateTitleOffsetOff", CalculateTitleOffsetOff);

	Nan::SetPrototypeMethod(tpl, "CalculateTitleOffsetOn", CalculateTitleOffsetOn);
	Nan::SetPrototypeMethod(tpl, "calculateTitleOffsetOn", CalculateTitleOffsetOn);

	Nan::SetPrototypeMethod(tpl, "ComputeMaxLabelLength", ComputeMaxLabelLength);
	Nan::SetPrototypeMethod(tpl, "computeMaxLabelLength", ComputeMaxLabelLength);

	Nan::SetPrototypeMethod(tpl, "ComputeTitleLength", ComputeTitleLength);
	Nan::SetPrototypeMethod(tpl, "computeTitleLength", ComputeTitleLength);

	Nan::SetPrototypeMethod(tpl, "DrawGridlinesOff", DrawGridlinesOff);
	Nan::SetPrototypeMethod(tpl, "drawGridlinesOff", DrawGridlinesOff);

	Nan::SetPrototypeMethod(tpl, "DrawGridlinesOn", DrawGridlinesOn);
	Nan::SetPrototypeMethod(tpl, "drawGridlinesOn", DrawGridlinesOn);

	Nan::SetPrototypeMethod(tpl, "DrawGridlinesOnlyOff", DrawGridlinesOnlyOff);
	Nan::SetPrototypeMethod(tpl, "drawGridlinesOnlyOff", DrawGridlinesOnlyOff);

	Nan::SetPrototypeMethod(tpl, "DrawGridlinesOnlyOn", DrawGridlinesOnlyOn);
	Nan::SetPrototypeMethod(tpl, "drawGridlinesOnlyOn", DrawGridlinesOnlyOn);

	Nan::SetPrototypeMethod(tpl, "DrawGridpolysOff", DrawGridpolysOff);
	Nan::SetPrototypeMethod(tpl, "drawGridpolysOff", DrawGridpolysOff);

	Nan::SetPrototypeMethod(tpl, "DrawGridpolysOn", DrawGridpolysOn);
	Nan::SetPrototypeMethod(tpl, "drawGridpolysOn", DrawGridpolysOn);

	Nan::SetPrototypeMethod(tpl, "DrawInnerGridlinesOff", DrawInnerGridlinesOff);
	Nan::SetPrototypeMethod(tpl, "drawInnerGridlinesOff", DrawInnerGridlinesOff);

	Nan::SetPrototypeMethod(tpl, "DrawInnerGridlinesOn", DrawInnerGridlinesOn);
	Nan::SetPrototypeMethod(tpl, "drawInnerGridlinesOn", DrawInnerGridlinesOn);

	Nan::SetPrototypeMethod(tpl, "GetAxisBaseForX", GetAxisBaseForX);
	Nan::SetPrototypeMethod(tpl, "getAxisBaseForX", GetAxisBaseForX);

	Nan::SetPrototypeMethod(tpl, "GetAxisBaseForY", GetAxisBaseForY);
	Nan::SetPrototypeMethod(tpl, "getAxisBaseForY", GetAxisBaseForY);

	Nan::SetPrototypeMethod(tpl, "GetAxisBaseForZ", GetAxisBaseForZ);
	Nan::SetPrototypeMethod(tpl, "getAxisBaseForZ", GetAxisBaseForZ);

	Nan::SetPrototypeMethod(tpl, "GetAxisLinesProperty", GetAxisLinesProperty);
	Nan::SetPrototypeMethod(tpl, "getAxisLinesProperty", GetAxisLinesProperty);

	Nan::SetPrototypeMethod(tpl, "GetAxisOnOrigin", GetAxisOnOrigin);
	Nan::SetPrototypeMethod(tpl, "getAxisOnOrigin", GetAxisOnOrigin);

	Nan::SetPrototypeMethod(tpl, "GetAxisPosition", GetAxisPosition);
	Nan::SetPrototypeMethod(tpl, "getAxisPosition", GetAxisPosition);

	Nan::SetPrototypeMethod(tpl, "GetAxisPositionMaxValue", GetAxisPositionMaxValue);
	Nan::SetPrototypeMethod(tpl, "getAxisPositionMaxValue", GetAxisPositionMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetAxisPositionMinValue", GetAxisPositionMinValue);
	Nan::SetPrototypeMethod(tpl, "getAxisPositionMinValue", GetAxisPositionMinValue);

	Nan::SetPrototypeMethod(tpl, "GetAxisType", GetAxisType);
	Nan::SetPrototypeMethod(tpl, "getAxisType", GetAxisType);

	Nan::SetPrototypeMethod(tpl, "GetAxisTypeMaxValue", GetAxisTypeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getAxisTypeMaxValue", GetAxisTypeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetAxisTypeMinValue", GetAxisTypeMinValue);
	Nan::SetPrototypeMethod(tpl, "getAxisTypeMinValue", GetAxisTypeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetAxisVisibility", GetAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getAxisVisibility", GetAxisVisibility);

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

	Nan::SetPrototypeMethod(tpl, "GetCalculateLabelOffset", GetCalculateLabelOffset);
	Nan::SetPrototypeMethod(tpl, "getCalculateLabelOffset", GetCalculateLabelOffset);

	Nan::SetPrototypeMethod(tpl, "GetCalculateTitleOffset", GetCalculateTitleOffset);
	Nan::SetPrototypeMethod(tpl, "getCalculateTitleOffset", GetCalculateTitleOffset);

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

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

	Nan::SetPrototypeMethod(tpl, "GetDeltaMajor", GetDeltaMajor);
	Nan::SetPrototypeMethod(tpl, "getDeltaMajor", GetDeltaMajor);

	Nan::SetPrototypeMethod(tpl, "GetDeltaMinor", GetDeltaMinor);
	Nan::SetPrototypeMethod(tpl, "getDeltaMinor", GetDeltaMinor);

	Nan::SetPrototypeMethod(tpl, "GetDeltaRangeMajor", GetDeltaRangeMajor);
	Nan::SetPrototypeMethod(tpl, "getDeltaRangeMajor", GetDeltaRangeMajor);

	Nan::SetPrototypeMethod(tpl, "GetDeltaRangeMinor", GetDeltaRangeMinor);
	Nan::SetPrototypeMethod(tpl, "getDeltaRangeMinor", GetDeltaRangeMinor);

	Nan::SetPrototypeMethod(tpl, "GetDrawGridlines", GetDrawGridlines);
	Nan::SetPrototypeMethod(tpl, "getDrawGridlines", GetDrawGridlines);

	Nan::SetPrototypeMethod(tpl, "GetDrawGridlinesLocation", GetDrawGridlinesLocation);
	Nan::SetPrototypeMethod(tpl, "getDrawGridlinesLocation", GetDrawGridlinesLocation);

	Nan::SetPrototypeMethod(tpl, "GetDrawGridlinesOnly", GetDrawGridlinesOnly);
	Nan::SetPrototypeMethod(tpl, "getDrawGridlinesOnly", GetDrawGridlinesOnly);

	Nan::SetPrototypeMethod(tpl, "GetDrawGridpolys", GetDrawGridpolys);
	Nan::SetPrototypeMethod(tpl, "getDrawGridpolys", GetDrawGridpolys);

	Nan::SetPrototypeMethod(tpl, "GetDrawInnerGridlines", GetDrawInnerGridlines);
	Nan::SetPrototypeMethod(tpl, "getDrawInnerGridlines", GetDrawInnerGridlines);

	Nan::SetPrototypeMethod(tpl, "GetGridlineXLength", GetGridlineXLength);
	Nan::SetPrototypeMethod(tpl, "getGridlineXLength", GetGridlineXLength);

	Nan::SetPrototypeMethod(tpl, "GetGridlineYLength", GetGridlineYLength);
	Nan::SetPrototypeMethod(tpl, "getGridlineYLength", GetGridlineYLength);

	Nan::SetPrototypeMethod(tpl, "GetGridlineZLength", GetGridlineZLength);
	Nan::SetPrototypeMethod(tpl, "getGridlineZLength", GetGridlineZLength);

	Nan::SetPrototypeMethod(tpl, "GetGridlinesProperty", GetGridlinesProperty);
	Nan::SetPrototypeMethod(tpl, "getGridlinesProperty", GetGridlinesProperty);

	Nan::SetPrototypeMethod(tpl, "GetGridpolysProperty", GetGridpolysProperty);
	Nan::SetPrototypeMethod(tpl, "getGridpolysProperty", GetGridpolysProperty);

	Nan::SetPrototypeMethod(tpl, "GetHorizontalOffsetYTitle2D", GetHorizontalOffsetYTitle2D);
	Nan::SetPrototypeMethod(tpl, "getHorizontalOffsetYTitle2D", GetHorizontalOffsetYTitle2D);

	Nan::SetPrototypeMethod(tpl, "GetInnerGridlinesProperty", GetInnerGridlinesProperty);
	Nan::SetPrototypeMethod(tpl, "getInnerGridlinesProperty", GetInnerGridlinesProperty);

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

	Nan::SetPrototypeMethod(tpl, "GetLabelOffset", GetLabelOffset);
	Nan::SetPrototypeMethod(tpl, "getLabelOffset", GetLabelOffset);

	Nan::SetPrototypeMethod(tpl, "GetLabelTextProperty", GetLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "getLabelTextProperty", GetLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetLabelVisibility", GetLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "getLabelVisibility", GetLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "GetMajorRangeStart", GetMajorRangeStart);
	Nan::SetPrototypeMethod(tpl, "getMajorRangeStart", GetMajorRangeStart);

	Nan::SetPrototypeMethod(tpl, "GetMajorStart", GetMajorStart);
	Nan::SetPrototypeMethod(tpl, "getMajorStart", GetMajorStart);

	Nan::SetPrototypeMethod(tpl, "GetMajorTickSize", GetMajorTickSize);
	Nan::SetPrototypeMethod(tpl, "getMajorTickSize", GetMajorTickSize);

	Nan::SetPrototypeMethod(tpl, "GetMinorRangeStart", GetMinorRangeStart);
	Nan::SetPrototypeMethod(tpl, "getMinorRangeStart", GetMinorRangeStart);

	Nan::SetPrototypeMethod(tpl, "GetMinorStart", GetMinorStart);
	Nan::SetPrototypeMethod(tpl, "getMinorStart", GetMinorStart);

	Nan::SetPrototypeMethod(tpl, "GetMinorTickSize", GetMinorTickSize);
	Nan::SetPrototypeMethod(tpl, "getMinorTickSize", GetMinorTickSize);

	Nan::SetPrototypeMethod(tpl, "GetMinorTicksVisible", GetMinorTicksVisible);
	Nan::SetPrototypeMethod(tpl, "getMinorTicksVisible", GetMinorTicksVisible);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfLabelsBuilt", GetNumberOfLabelsBuilt);
	Nan::SetPrototypeMethod(tpl, "getNumberOfLabelsBuilt", GetNumberOfLabelsBuilt);

	Nan::SetPrototypeMethod(tpl, "GetPoint1Coordinate", GetPoint1Coordinate);
	Nan::SetPrototypeMethod(tpl, "getPoint1Coordinate", GetPoint1Coordinate);

	Nan::SetPrototypeMethod(tpl, "GetPoint2Coordinate", GetPoint2Coordinate);
	Nan::SetPrototypeMethod(tpl, "getPoint2Coordinate", GetPoint2Coordinate);

	Nan::SetPrototypeMethod(tpl, "GetRange", GetRange);
	Nan::SetPrototypeMethod(tpl, "getRange", GetRange);

	Nan::SetPrototypeMethod(tpl, "GetSaveTitlePosition", GetSaveTitlePosition);
	Nan::SetPrototypeMethod(tpl, "getSaveTitlePosition", GetSaveTitlePosition);

	Nan::SetPrototypeMethod(tpl, "GetScreenSize", GetScreenSize);
	Nan::SetPrototypeMethod(tpl, "getScreenSize", GetScreenSize);

	Nan::SetPrototypeMethod(tpl, "GetTickLocation", GetTickLocation);
	Nan::SetPrototypeMethod(tpl, "getTickLocation", GetTickLocation);

	Nan::SetPrototypeMethod(tpl, "GetTickLocationMaxValue", GetTickLocationMaxValue);
	Nan::SetPrototypeMethod(tpl, "getTickLocationMaxValue", GetTickLocationMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetTickLocationMinValue", GetTickLocationMinValue);
	Nan::SetPrototypeMethod(tpl, "getTickLocationMinValue", GetTickLocationMinValue);

	Nan::SetPrototypeMethod(tpl, "GetTickVisibility", GetTickVisibility);
	Nan::SetPrototypeMethod(tpl, "getTickVisibility", GetTickVisibility);

	Nan::SetPrototypeMethod(tpl, "GetTitle", GetTitle);
	Nan::SetPrototypeMethod(tpl, "getTitle", GetTitle);

	Nan::SetPrototypeMethod(tpl, "GetTitleActor", GetTitleActor);
	Nan::SetPrototypeMethod(tpl, "getTitleActor", GetTitleActor);

	Nan::SetPrototypeMethod(tpl, "GetTitleOffset", GetTitleOffset);
	Nan::SetPrototypeMethod(tpl, "getTitleOffset", GetTitleOffset);

	Nan::SetPrototypeMethod(tpl, "GetTitleProp3D", GetTitleProp3D);
	Nan::SetPrototypeMethod(tpl, "getTitleProp3D", GetTitleProp3D);

	Nan::SetPrototypeMethod(tpl, "GetTitleTextProperty", GetTitleTextProperty);
	Nan::SetPrototypeMethod(tpl, "getTitleTextProperty", GetTitleTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetTitleVisibility", GetTitleVisibility);
	Nan::SetPrototypeMethod(tpl, "getTitleVisibility", GetTitleVisibility);

	Nan::SetPrototypeMethod(tpl, "GetUse2DMode", GetUse2DMode);
	Nan::SetPrototypeMethod(tpl, "getUse2DMode", GetUse2DMode);

	Nan::SetPrototypeMethod(tpl, "GetUseTextActor3D", GetUseTextActor3D);
	Nan::SetPrototypeMethod(tpl, "getUseTextActor3D", GetUseTextActor3D);

	Nan::SetPrototypeMethod(tpl, "GetVerticalOffsetXTitle2D", GetVerticalOffsetXTitle2D);
	Nan::SetPrototypeMethod(tpl, "getVerticalOffsetXTitle2D", GetVerticalOffsetXTitle2D);

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

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

	Nan::SetPrototypeMethod(tpl, "LabelVisibilityOff", LabelVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "labelVisibilityOff", LabelVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "LabelVisibilityOn", LabelVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "labelVisibilityOn", LabelVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "MinorTicksVisibleOff", MinorTicksVisibleOff);
	Nan::SetPrototypeMethod(tpl, "minorTicksVisibleOff", MinorTicksVisibleOff);

	Nan::SetPrototypeMethod(tpl, "MinorTicksVisibleOn", MinorTicksVisibleOn);
	Nan::SetPrototypeMethod(tpl, "minorTicksVisibleOn", MinorTicksVisibleOn);

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

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

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

	Nan::SetPrototypeMethod(tpl, "SetAxisBaseForX", SetAxisBaseForX);
	Nan::SetPrototypeMethod(tpl, "setAxisBaseForX", SetAxisBaseForX);

	Nan::SetPrototypeMethod(tpl, "SetAxisBaseForY", SetAxisBaseForY);
	Nan::SetPrototypeMethod(tpl, "setAxisBaseForY", SetAxisBaseForY);

	Nan::SetPrototypeMethod(tpl, "SetAxisBaseForZ", SetAxisBaseForZ);
	Nan::SetPrototypeMethod(tpl, "setAxisBaseForZ", SetAxisBaseForZ);

	Nan::SetPrototypeMethod(tpl, "SetAxisLinesProperty", SetAxisLinesProperty);
	Nan::SetPrototypeMethod(tpl, "setAxisLinesProperty", SetAxisLinesProperty);

	Nan::SetPrototypeMethod(tpl, "SetAxisOnOrigin", SetAxisOnOrigin);
	Nan::SetPrototypeMethod(tpl, "setAxisOnOrigin", SetAxisOnOrigin);

	Nan::SetPrototypeMethod(tpl, "SetAxisPosition", SetAxisPosition);
	Nan::SetPrototypeMethod(tpl, "setAxisPosition", SetAxisPosition);

	Nan::SetPrototypeMethod(tpl, "SetAxisPositionToMaxMax", SetAxisPositionToMaxMax);
	Nan::SetPrototypeMethod(tpl, "setAxisPositionToMaxMax", SetAxisPositionToMaxMax);

	Nan::SetPrototypeMethod(tpl, "SetAxisPositionToMaxMin", SetAxisPositionToMaxMin);
	Nan::SetPrototypeMethod(tpl, "setAxisPositionToMaxMin", SetAxisPositionToMaxMin);

	Nan::SetPrototypeMethod(tpl, "SetAxisPositionToMinMax", SetAxisPositionToMinMax);
	Nan::SetPrototypeMethod(tpl, "setAxisPositionToMinMax", SetAxisPositionToMinMax);

	Nan::SetPrototypeMethod(tpl, "SetAxisPositionToMinMin", SetAxisPositionToMinMin);
	Nan::SetPrototypeMethod(tpl, "setAxisPositionToMinMin", SetAxisPositionToMinMin);

	Nan::SetPrototypeMethod(tpl, "SetAxisType", SetAxisType);
	Nan::SetPrototypeMethod(tpl, "setAxisType", SetAxisType);

	Nan::SetPrototypeMethod(tpl, "SetAxisTypeToX", SetAxisTypeToX);
	Nan::SetPrototypeMethod(tpl, "setAxisTypeToX", SetAxisTypeToX);

	Nan::SetPrototypeMethod(tpl, "SetAxisTypeToY", SetAxisTypeToY);
	Nan::SetPrototypeMethod(tpl, "setAxisTypeToY", SetAxisTypeToY);

	Nan::SetPrototypeMethod(tpl, "SetAxisTypeToZ", SetAxisTypeToZ);
	Nan::SetPrototypeMethod(tpl, "setAxisTypeToZ", SetAxisTypeToZ);

	Nan::SetPrototypeMethod(tpl, "SetAxisVisibility", SetAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setAxisVisibility", SetAxisVisibility);

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

	Nan::SetPrototypeMethod(tpl, "SetCalculateLabelOffset", SetCalculateLabelOffset);
	Nan::SetPrototypeMethod(tpl, "setCalculateLabelOffset", SetCalculateLabelOffset);

	Nan::SetPrototypeMethod(tpl, "SetCalculateTitleOffset", SetCalculateTitleOffset);
	Nan::SetPrototypeMethod(tpl, "setCalculateTitleOffset", SetCalculateTitleOffset);

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

	Nan::SetPrototypeMethod(tpl, "SetDeltaMajor", SetDeltaMajor);
	Nan::SetPrototypeMethod(tpl, "setDeltaMajor", SetDeltaMajor);

	Nan::SetPrototypeMethod(tpl, "SetDeltaMinor", SetDeltaMinor);
	Nan::SetPrototypeMethod(tpl, "setDeltaMinor", SetDeltaMinor);

	Nan::SetPrototypeMethod(tpl, "SetDeltaRangeMajor", SetDeltaRangeMajor);
	Nan::SetPrototypeMethod(tpl, "setDeltaRangeMajor", SetDeltaRangeMajor);

	Nan::SetPrototypeMethod(tpl, "SetDeltaRangeMinor", SetDeltaRangeMinor);
	Nan::SetPrototypeMethod(tpl, "setDeltaRangeMinor", SetDeltaRangeMinor);

	Nan::SetPrototypeMethod(tpl, "SetDrawGridlines", SetDrawGridlines);
	Nan::SetPrototypeMethod(tpl, "setDrawGridlines", SetDrawGridlines);

	Nan::SetPrototypeMethod(tpl, "SetDrawGridlinesLocation", SetDrawGridlinesLocation);
	Nan::SetPrototypeMethod(tpl, "setDrawGridlinesLocation", SetDrawGridlinesLocation);

	Nan::SetPrototypeMethod(tpl, "SetDrawGridlinesOnly", SetDrawGridlinesOnly);
	Nan::SetPrototypeMethod(tpl, "setDrawGridlinesOnly", SetDrawGridlinesOnly);

	Nan::SetPrototypeMethod(tpl, "SetDrawGridpolys", SetDrawGridpolys);
	Nan::SetPrototypeMethod(tpl, "setDrawGridpolys", SetDrawGridpolys);

	Nan::SetPrototypeMethod(tpl, "SetDrawInnerGridlines", SetDrawInnerGridlines);
	Nan::SetPrototypeMethod(tpl, "setDrawInnerGridlines", SetDrawInnerGridlines);

	Nan::SetPrototypeMethod(tpl, "SetGridlineXLength", SetGridlineXLength);
	Nan::SetPrototypeMethod(tpl, "setGridlineXLength", SetGridlineXLength);

	Nan::SetPrototypeMethod(tpl, "SetGridlineYLength", SetGridlineYLength);
	Nan::SetPrototypeMethod(tpl, "setGridlineYLength", SetGridlineYLength);

	Nan::SetPrototypeMethod(tpl, "SetGridlineZLength", SetGridlineZLength);
	Nan::SetPrototypeMethod(tpl, "setGridlineZLength", SetGridlineZLength);

	Nan::SetPrototypeMethod(tpl, "SetGridlinesProperty", SetGridlinesProperty);
	Nan::SetPrototypeMethod(tpl, "setGridlinesProperty", SetGridlinesProperty);

	Nan::SetPrototypeMethod(tpl, "SetGridpolysProperty", SetGridpolysProperty);
	Nan::SetPrototypeMethod(tpl, "setGridpolysProperty", SetGridpolysProperty);

	Nan::SetPrototypeMethod(tpl, "SetHorizontalOffsetYTitle2D", SetHorizontalOffsetYTitle2D);
	Nan::SetPrototypeMethod(tpl, "setHorizontalOffsetYTitle2D", SetHorizontalOffsetYTitle2D);

	Nan::SetPrototypeMethod(tpl, "SetInnerGridlinesProperty", SetInnerGridlinesProperty);
	Nan::SetPrototypeMethod(tpl, "setInnerGridlinesProperty", SetInnerGridlinesProperty);

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

	Nan::SetPrototypeMethod(tpl, "SetLabelOffset", SetLabelOffset);
	Nan::SetPrototypeMethod(tpl, "setLabelOffset", SetLabelOffset);

	Nan::SetPrototypeMethod(tpl, "SetLabelScale", SetLabelScale);
	Nan::SetPrototypeMethod(tpl, "setLabelScale", SetLabelScale);

	Nan::SetPrototypeMethod(tpl, "SetLabelTextProperty", SetLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "setLabelTextProperty", SetLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetLabelVisibility", SetLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "setLabelVisibility", SetLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "SetLabels", SetLabels);
	Nan::SetPrototypeMethod(tpl, "setLabels", SetLabels);

	Nan::SetPrototypeMethod(tpl, "SetMajorRangeStart", SetMajorRangeStart);
	Nan::SetPrototypeMethod(tpl, "setMajorRangeStart", SetMajorRangeStart);

	Nan::SetPrototypeMethod(tpl, "SetMajorStart", SetMajorStart);
	Nan::SetPrototypeMethod(tpl, "setMajorStart", SetMajorStart);

	Nan::SetPrototypeMethod(tpl, "SetMajorTickSize", SetMajorTickSize);
	Nan::SetPrototypeMethod(tpl, "setMajorTickSize", SetMajorTickSize);

	Nan::SetPrototypeMethod(tpl, "SetMinorRangeStart", SetMinorRangeStart);
	Nan::SetPrototypeMethod(tpl, "setMinorRangeStart", SetMinorRangeStart);

	Nan::SetPrototypeMethod(tpl, "SetMinorStart", SetMinorStart);
	Nan::SetPrototypeMethod(tpl, "setMinorStart", SetMinorStart);

	Nan::SetPrototypeMethod(tpl, "SetMinorTickSize", SetMinorTickSize);
	Nan::SetPrototypeMethod(tpl, "setMinorTickSize", SetMinorTickSize);

	Nan::SetPrototypeMethod(tpl, "SetMinorTicksVisible", SetMinorTicksVisible);
	Nan::SetPrototypeMethod(tpl, "setMinorTicksVisible", SetMinorTicksVisible);

	Nan::SetPrototypeMethod(tpl, "SetPoint1", SetPoint1);
	Nan::SetPrototypeMethod(tpl, "setPoint1", SetPoint1);

	Nan::SetPrototypeMethod(tpl, "SetPoint2", SetPoint2);
	Nan::SetPrototypeMethod(tpl, "setPoint2", SetPoint2);

	Nan::SetPrototypeMethod(tpl, "SetRange", SetRange);
	Nan::SetPrototypeMethod(tpl, "setRange", SetRange);

	Nan::SetPrototypeMethod(tpl, "SetSaveTitlePosition", SetSaveTitlePosition);
	Nan::SetPrototypeMethod(tpl, "setSaveTitlePosition", SetSaveTitlePosition);

	Nan::SetPrototypeMethod(tpl, "SetScreenSize", SetScreenSize);
	Nan::SetPrototypeMethod(tpl, "setScreenSize", SetScreenSize);

	Nan::SetPrototypeMethod(tpl, "SetTickLocation", SetTickLocation);
	Nan::SetPrototypeMethod(tpl, "setTickLocation", SetTickLocation);

	Nan::SetPrototypeMethod(tpl, "SetTickLocationToBoth", SetTickLocationToBoth);
	Nan::SetPrototypeMethod(tpl, "setTickLocationToBoth", SetTickLocationToBoth);

	Nan::SetPrototypeMethod(tpl, "SetTickLocationToInside", SetTickLocationToInside);
	Nan::SetPrototypeMethod(tpl, "setTickLocationToInside", SetTickLocationToInside);

	Nan::SetPrototypeMethod(tpl, "SetTickLocationToOutside", SetTickLocationToOutside);
	Nan::SetPrototypeMethod(tpl, "setTickLocationToOutside", SetTickLocationToOutside);

	Nan::SetPrototypeMethod(tpl, "SetTickVisibility", SetTickVisibility);
	Nan::SetPrototypeMethod(tpl, "setTickVisibility", SetTickVisibility);

	Nan::SetPrototypeMethod(tpl, "SetTitle", SetTitle);
	Nan::SetPrototypeMethod(tpl, "setTitle", SetTitle);

	Nan::SetPrototypeMethod(tpl, "SetTitleOffset", SetTitleOffset);
	Nan::SetPrototypeMethod(tpl, "setTitleOffset", SetTitleOffset);

	Nan::SetPrototypeMethod(tpl, "SetTitleScale", SetTitleScale);
	Nan::SetPrototypeMethod(tpl, "setTitleScale", SetTitleScale);

	Nan::SetPrototypeMethod(tpl, "SetTitleTextProperty", SetTitleTextProperty);
	Nan::SetPrototypeMethod(tpl, "setTitleTextProperty", SetTitleTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetTitleVisibility", SetTitleVisibility);
	Nan::SetPrototypeMethod(tpl, "setTitleVisibility", SetTitleVisibility);

	Nan::SetPrototypeMethod(tpl, "SetUse2DMode", SetUse2DMode);
	Nan::SetPrototypeMethod(tpl, "setUse2DMode", SetUse2DMode);

	Nan::SetPrototypeMethod(tpl, "SetUseTextActor3D", SetUseTextActor3D);
	Nan::SetPrototypeMethod(tpl, "setUseTextActor3D", SetUseTextActor3D);

	Nan::SetPrototypeMethod(tpl, "SetVerticalOffsetXTitle2D", SetVerticalOffsetXTitle2D);
	Nan::SetPrototypeMethod(tpl, "setVerticalOffsetXTitle2D", SetVerticalOffsetXTitle2D);

	Nan::SetPrototypeMethod(tpl, "TickVisibilityOff", TickVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "tickVisibilityOff", TickVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "TickVisibilityOn", TickVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "tickVisibilityOn", TickVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "TitleVisibilityOff", TitleVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "titleVisibilityOff", TitleVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "TitleVisibilityOn", TitleVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "titleVisibilityOn", TitleVisibilityOn);

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

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

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

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

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

void VtkAxisActorWrap::BuildAxis(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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());
		if(info.Length() > 1 && info[1]->IsBoolean())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->BuildAxis(
				(vtkViewport *) a0->native.GetPointer(),
				info[1]->BooleanValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
		double r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->ComputeMaxLabelLength(
			b0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
		double r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->ComputeTitleLength(
			b0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkAxisActorWrap::GetCamera(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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 VtkAxisActorWrap::GetClassName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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 VtkAxisActorWrap::GetDeltaMajor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		double r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetDeltaMajor(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkAxisActorWrap::HasTranslucentPolygonalGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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 VtkAxisActorWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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 VtkAxisActorWrap::LabelVisibilityOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->LabelVisibilityOff();
}

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

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

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

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

void VtkAxisActorWrap::ReleaseGraphicsResources(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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 VtkAxisActorWrap::RenderOpaqueGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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 VtkAxisActorWrap::RenderOverlay(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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 VtkAxisActorWrap::RenderTranslucentGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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->RenderTranslucentGeometry(
			(vtkViewport *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkAxisActorWrap::SetLabelFormat(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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 VtkAxisActorWrap::SetLabelOffset(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLabelOffset(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkAxisActorWrap::SetRange(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkAxisActorWrap *wrapper = ObjectWrap::Unwrap<VtkAxisActorWrap>(info.Holder());
	vtkAxisActor *native = (vtkAxisActor *)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() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

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

		for( i = 0; i < 2; 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->SetRange(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetRange(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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