/* 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 "vtkPropWrap.h"
#include "vtkLegendScaleActorWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkTextPropertyWrap.h"
#include "vtkAxisActor2DWrap.h"
#include "vtkViewportWrap.h"
#include "vtkPropCollectionWrap.h"
#include "vtkWindowWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkLegendScaleActorWrap::VtkLegendScaleActorWrap()
{ }

VtkLegendScaleActorWrap::VtkLegendScaleActorWrap(vtkSmartPointer<vtkLegendScaleActor> _native)
{ native = _native; }

VtkLegendScaleActorWrap::~VtkLegendScaleActorWrap()
{ }

void VtkLegendScaleActorWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkLegendScaleActor").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("LegendScaleActor").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "AllAnnotationsOff", AllAnnotationsOff);
	Nan::SetPrototypeMethod(tpl, "allAnnotationsOff", AllAnnotationsOff);

	Nan::SetPrototypeMethod(tpl, "AllAnnotationsOn", AllAnnotationsOn);
	Nan::SetPrototypeMethod(tpl, "allAnnotationsOn", AllAnnotationsOn);

	Nan::SetPrototypeMethod(tpl, "AllAxesOff", AllAxesOff);
	Nan::SetPrototypeMethod(tpl, "allAxesOff", AllAxesOff);

	Nan::SetPrototypeMethod(tpl, "AllAxesOn", AllAxesOn);
	Nan::SetPrototypeMethod(tpl, "allAxesOn", AllAxesOn);

	Nan::SetPrototypeMethod(tpl, "BottomAxisVisibilityOff", BottomAxisVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "bottomAxisVisibilityOff", BottomAxisVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "BottomAxisVisibilityOn", BottomAxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "bottomAxisVisibilityOn", BottomAxisVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "BuildRepresentation", BuildRepresentation);
	Nan::SetPrototypeMethod(tpl, "buildRepresentation", BuildRepresentation);

	Nan::SetPrototypeMethod(tpl, "GetActors2D", GetActors2D);
	Nan::SetPrototypeMethod(tpl, "getActors2D", GetActors2D);

	Nan::SetPrototypeMethod(tpl, "GetBottomAxis", GetBottomAxis);
	Nan::SetPrototypeMethod(tpl, "getBottomAxis", GetBottomAxis);

	Nan::SetPrototypeMethod(tpl, "GetBottomAxisVisibility", GetBottomAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getBottomAxisVisibility", GetBottomAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "GetBottomBorderOffset", GetBottomBorderOffset);
	Nan::SetPrototypeMethod(tpl, "getBottomBorderOffset", GetBottomBorderOffset);

	Nan::SetPrototypeMethod(tpl, "GetBottomBorderOffsetMaxValue", GetBottomBorderOffsetMaxValue);
	Nan::SetPrototypeMethod(tpl, "getBottomBorderOffsetMaxValue", GetBottomBorderOffsetMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetBottomBorderOffsetMinValue", GetBottomBorderOffsetMinValue);
	Nan::SetPrototypeMethod(tpl, "getBottomBorderOffsetMinValue", GetBottomBorderOffsetMinValue);

	Nan::SetPrototypeMethod(tpl, "GetCornerOffsetFactor", GetCornerOffsetFactor);
	Nan::SetPrototypeMethod(tpl, "getCornerOffsetFactor", GetCornerOffsetFactor);

	Nan::SetPrototypeMethod(tpl, "GetCornerOffsetFactorMaxValue", GetCornerOffsetFactorMaxValue);
	Nan::SetPrototypeMethod(tpl, "getCornerOffsetFactorMaxValue", GetCornerOffsetFactorMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetCornerOffsetFactorMinValue", GetCornerOffsetFactorMinValue);
	Nan::SetPrototypeMethod(tpl, "getCornerOffsetFactorMinValue", GetCornerOffsetFactorMinValue);

	Nan::SetPrototypeMethod(tpl, "GetLabelMode", GetLabelMode);
	Nan::SetPrototypeMethod(tpl, "getLabelMode", GetLabelMode);

	Nan::SetPrototypeMethod(tpl, "GetLabelModeMaxValue", GetLabelModeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getLabelModeMaxValue", GetLabelModeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetLabelModeMinValue", GetLabelModeMinValue);
	Nan::SetPrototypeMethod(tpl, "getLabelModeMinValue", GetLabelModeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetLeftAxis", GetLeftAxis);
	Nan::SetPrototypeMethod(tpl, "getLeftAxis", GetLeftAxis);

	Nan::SetPrototypeMethod(tpl, "GetLeftAxisVisibility", GetLeftAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getLeftAxisVisibility", GetLeftAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "GetLeftBorderOffset", GetLeftBorderOffset);
	Nan::SetPrototypeMethod(tpl, "getLeftBorderOffset", GetLeftBorderOffset);

	Nan::SetPrototypeMethod(tpl, "GetLeftBorderOffsetMaxValue", GetLeftBorderOffsetMaxValue);
	Nan::SetPrototypeMethod(tpl, "getLeftBorderOffsetMaxValue", GetLeftBorderOffsetMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetLeftBorderOffsetMinValue", GetLeftBorderOffsetMinValue);
	Nan::SetPrototypeMethod(tpl, "getLeftBorderOffsetMinValue", GetLeftBorderOffsetMinValue);

	Nan::SetPrototypeMethod(tpl, "GetLegendLabelProperty", GetLegendLabelProperty);
	Nan::SetPrototypeMethod(tpl, "getLegendLabelProperty", GetLegendLabelProperty);

	Nan::SetPrototypeMethod(tpl, "GetLegendTitleProperty", GetLegendTitleProperty);
	Nan::SetPrototypeMethod(tpl, "getLegendTitleProperty", GetLegendTitleProperty);

	Nan::SetPrototypeMethod(tpl, "GetLegendVisibility", GetLegendVisibility);
	Nan::SetPrototypeMethod(tpl, "getLegendVisibility", GetLegendVisibility);

	Nan::SetPrototypeMethod(tpl, "GetRightAxis", GetRightAxis);
	Nan::SetPrototypeMethod(tpl, "getRightAxis", GetRightAxis);

	Nan::SetPrototypeMethod(tpl, "GetRightAxisVisibility", GetRightAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getRightAxisVisibility", GetRightAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "GetRightBorderOffset", GetRightBorderOffset);
	Nan::SetPrototypeMethod(tpl, "getRightBorderOffset", GetRightBorderOffset);

	Nan::SetPrototypeMethod(tpl, "GetRightBorderOffsetMaxValue", GetRightBorderOffsetMaxValue);
	Nan::SetPrototypeMethod(tpl, "getRightBorderOffsetMaxValue", GetRightBorderOffsetMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetRightBorderOffsetMinValue", GetRightBorderOffsetMinValue);
	Nan::SetPrototypeMethod(tpl, "getRightBorderOffsetMinValue", GetRightBorderOffsetMinValue);

	Nan::SetPrototypeMethod(tpl, "GetTopAxis", GetTopAxis);
	Nan::SetPrototypeMethod(tpl, "getTopAxis", GetTopAxis);

	Nan::SetPrototypeMethod(tpl, "GetTopAxisVisibility", GetTopAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getTopAxisVisibility", GetTopAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "GetTopBorderOffset", GetTopBorderOffset);
	Nan::SetPrototypeMethod(tpl, "getTopBorderOffset", GetTopBorderOffset);

	Nan::SetPrototypeMethod(tpl, "GetTopBorderOffsetMaxValue", GetTopBorderOffsetMaxValue);
	Nan::SetPrototypeMethod(tpl, "getTopBorderOffsetMaxValue", GetTopBorderOffsetMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetTopBorderOffsetMinValue", GetTopBorderOffsetMinValue);
	Nan::SetPrototypeMethod(tpl, "getTopBorderOffsetMinValue", GetTopBorderOffsetMinValue);

	Nan::SetPrototypeMethod(tpl, "LeftAxisVisibilityOff", LeftAxisVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "leftAxisVisibilityOff", LeftAxisVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "LeftAxisVisibilityOn", LeftAxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "leftAxisVisibilityOn", LeftAxisVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "LegendVisibilityOff", LegendVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "legendVisibilityOff", LegendVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "LegendVisibilityOn", LegendVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "legendVisibilityOn", LegendVisibilityOn);

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

	Nan::SetPrototypeMethod(tpl, "RightAxisVisibilityOn", RightAxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "rightAxisVisibilityOn", RightAxisVisibilityOn);

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

	Nan::SetPrototypeMethod(tpl, "SetBottomAxisVisibility", SetBottomAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setBottomAxisVisibility", SetBottomAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "SetBottomBorderOffset", SetBottomBorderOffset);
	Nan::SetPrototypeMethod(tpl, "setBottomBorderOffset", SetBottomBorderOffset);

	Nan::SetPrototypeMethod(tpl, "SetCornerOffsetFactor", SetCornerOffsetFactor);
	Nan::SetPrototypeMethod(tpl, "setCornerOffsetFactor", SetCornerOffsetFactor);

	Nan::SetPrototypeMethod(tpl, "SetLabelMode", SetLabelMode);
	Nan::SetPrototypeMethod(tpl, "setLabelMode", SetLabelMode);

	Nan::SetPrototypeMethod(tpl, "SetLabelModeToDistance", SetLabelModeToDistance);
	Nan::SetPrototypeMethod(tpl, "setLabelModeToDistance", SetLabelModeToDistance);

	Nan::SetPrototypeMethod(tpl, "SetLabelModeToXYCoordinates", SetLabelModeToXYCoordinates);
	Nan::SetPrototypeMethod(tpl, "setLabelModeToXYCoordinates", SetLabelModeToXYCoordinates);

	Nan::SetPrototypeMethod(tpl, "SetLeftAxisVisibility", SetLeftAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setLeftAxisVisibility", SetLeftAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "SetLeftBorderOffset", SetLeftBorderOffset);
	Nan::SetPrototypeMethod(tpl, "setLeftBorderOffset", SetLeftBorderOffset);

	Nan::SetPrototypeMethod(tpl, "SetLegendVisibility", SetLegendVisibility);
	Nan::SetPrototypeMethod(tpl, "setLegendVisibility", SetLegendVisibility);

	Nan::SetPrototypeMethod(tpl, "SetRightAxisVisibility", SetRightAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setRightAxisVisibility", SetRightAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "SetRightBorderOffset", SetRightBorderOffset);
	Nan::SetPrototypeMethod(tpl, "setRightBorderOffset", SetRightBorderOffset);

	Nan::SetPrototypeMethod(tpl, "SetTopAxisVisibility", SetTopAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setTopAxisVisibility", SetTopAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "SetTopBorderOffset", SetTopBorderOffset);
	Nan::SetPrototypeMethod(tpl, "setTopBorderOffset", SetTopBorderOffset);

	Nan::SetPrototypeMethod(tpl, "TopAxisVisibilityOff", TopAxisVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "topAxisVisibilityOff", TopAxisVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "TopAxisVisibilityOn", TopAxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "topAxisVisibilityOn", TopAxisVisibilityOn);

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

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

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

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

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

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

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

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

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

void VtkLegendScaleActorWrap::BuildRepresentation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLegendScaleActorWrap *wrapper = ObjectWrap::Unwrap<VtkLegendScaleActorWrap>(info.Holder());
	vtkLegendScaleActor *native = (vtkLegendScaleActor *)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)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->BuildRepresentation(
			(vtkViewport *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkLegendScaleActorWrap::ReleaseGraphicsResources(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLegendScaleActorWrap *wrapper = ObjectWrap::Unwrap<VtkLegendScaleActorWrap>(info.Holder());
	vtkLegendScaleActor *native = (vtkLegendScaleActor *)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 VtkLegendScaleActorWrap::RenderOpaqueGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLegendScaleActorWrap *wrapper = ObjectWrap::Unwrap<VtkLegendScaleActorWrap>(info.Holder());
	vtkLegendScaleActor *native = (vtkLegendScaleActor *)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 VtkLegendScaleActorWrap::RenderOverlay(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLegendScaleActorWrap *wrapper = ObjectWrap::Unwrap<VtkLegendScaleActorWrap>(info.Holder());
	vtkLegendScaleActor *native = (vtkLegendScaleActor *)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 VtkLegendScaleActorWrap::RightAxisVisibilityOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLegendScaleActorWrap *wrapper = ObjectWrap::Unwrap<VtkLegendScaleActorWrap>(info.Holder());
	vtkLegendScaleActor *native = (vtkLegendScaleActor *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->RightAxisVisibilityOff();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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