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

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

#include "vtkActor2DWrap.h"
#include "vtkScalarBarActorWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkViewportWrap.h"
#include "vtkWindowWrap.h"
#include "vtkScalarsToColorsWrap.h"
#include "vtkTextPropertyWrap.h"
#include "vtkPropWrap.h"
#include "vtkTexturedActor2DWrap.h"
#include "vtkProperty2DWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkScalarBarActorWrap::VtkScalarBarActorWrap()
{ }

VtkScalarBarActorWrap::VtkScalarBarActorWrap(vtkSmartPointer<vtkScalarBarActor> _native)
{ native = _native; }

VtkScalarBarActorWrap::~VtkScalarBarActorWrap()
{ }

void VtkScalarBarActorWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkScalarBarActor").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("ScalarBarActor").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "AnnotationTextScalingOff", AnnotationTextScalingOff);
	Nan::SetPrototypeMethod(tpl, "annotationTextScalingOff", AnnotationTextScalingOff);

	Nan::SetPrototypeMethod(tpl, "AnnotationTextScalingOn", AnnotationTextScalingOn);
	Nan::SetPrototypeMethod(tpl, "annotationTextScalingOn", AnnotationTextScalingOn);

	Nan::SetPrototypeMethod(tpl, "DrawAboveRangeSwatchOff", DrawAboveRangeSwatchOff);
	Nan::SetPrototypeMethod(tpl, "drawAboveRangeSwatchOff", DrawAboveRangeSwatchOff);

	Nan::SetPrototypeMethod(tpl, "DrawAboveRangeSwatchOn", DrawAboveRangeSwatchOn);
	Nan::SetPrototypeMethod(tpl, "drawAboveRangeSwatchOn", DrawAboveRangeSwatchOn);

	Nan::SetPrototypeMethod(tpl, "DrawAnnotationsOff", DrawAnnotationsOff);
	Nan::SetPrototypeMethod(tpl, "drawAnnotationsOff", DrawAnnotationsOff);

	Nan::SetPrototypeMethod(tpl, "DrawAnnotationsOn", DrawAnnotationsOn);
	Nan::SetPrototypeMethod(tpl, "drawAnnotationsOn", DrawAnnotationsOn);

	Nan::SetPrototypeMethod(tpl, "DrawBackgroundOff", DrawBackgroundOff);
	Nan::SetPrototypeMethod(tpl, "drawBackgroundOff", DrawBackgroundOff);

	Nan::SetPrototypeMethod(tpl, "DrawBackgroundOn", DrawBackgroundOn);
	Nan::SetPrototypeMethod(tpl, "drawBackgroundOn", DrawBackgroundOn);

	Nan::SetPrototypeMethod(tpl, "DrawBelowRangeSwatchOff", DrawBelowRangeSwatchOff);
	Nan::SetPrototypeMethod(tpl, "drawBelowRangeSwatchOff", DrawBelowRangeSwatchOff);

	Nan::SetPrototypeMethod(tpl, "DrawBelowRangeSwatchOn", DrawBelowRangeSwatchOn);
	Nan::SetPrototypeMethod(tpl, "drawBelowRangeSwatchOn", DrawBelowRangeSwatchOn);

	Nan::SetPrototypeMethod(tpl, "DrawColorBarOff", DrawColorBarOff);
	Nan::SetPrototypeMethod(tpl, "drawColorBarOff", DrawColorBarOff);

	Nan::SetPrototypeMethod(tpl, "DrawColorBarOn", DrawColorBarOn);
	Nan::SetPrototypeMethod(tpl, "drawColorBarOn", DrawColorBarOn);

	Nan::SetPrototypeMethod(tpl, "DrawFrameOff", DrawFrameOff);
	Nan::SetPrototypeMethod(tpl, "drawFrameOff", DrawFrameOff);

	Nan::SetPrototypeMethod(tpl, "DrawFrameOn", DrawFrameOn);
	Nan::SetPrototypeMethod(tpl, "drawFrameOn", DrawFrameOn);

	Nan::SetPrototypeMethod(tpl, "DrawNanAnnotationOff", DrawNanAnnotationOff);
	Nan::SetPrototypeMethod(tpl, "drawNanAnnotationOff", DrawNanAnnotationOff);

	Nan::SetPrototypeMethod(tpl, "DrawNanAnnotationOn", DrawNanAnnotationOn);
	Nan::SetPrototypeMethod(tpl, "drawNanAnnotationOn", DrawNanAnnotationOn);

	Nan::SetPrototypeMethod(tpl, "DrawTickLabelsOff", DrawTickLabelsOff);
	Nan::SetPrototypeMethod(tpl, "drawTickLabelsOff", DrawTickLabelsOff);

	Nan::SetPrototypeMethod(tpl, "DrawTickLabelsOn", DrawTickLabelsOn);
	Nan::SetPrototypeMethod(tpl, "drawTickLabelsOn", DrawTickLabelsOn);

	Nan::SetPrototypeMethod(tpl, "FixedAnnotationLeaderLineColorOff", FixedAnnotationLeaderLineColorOff);
	Nan::SetPrototypeMethod(tpl, "fixedAnnotationLeaderLineColorOff", FixedAnnotationLeaderLineColorOff);

	Nan::SetPrototypeMethod(tpl, "FixedAnnotationLeaderLineColorOn", FixedAnnotationLeaderLineColorOn);
	Nan::SetPrototypeMethod(tpl, "fixedAnnotationLeaderLineColorOn", FixedAnnotationLeaderLineColorOn);

	Nan::SetPrototypeMethod(tpl, "GetAboveRangeAnnotation", GetAboveRangeAnnotation);
	Nan::SetPrototypeMethod(tpl, "getAboveRangeAnnotation", GetAboveRangeAnnotation);

	Nan::SetPrototypeMethod(tpl, "GetAnnotationLeaderPadding", GetAnnotationLeaderPadding);
	Nan::SetPrototypeMethod(tpl, "getAnnotationLeaderPadding", GetAnnotationLeaderPadding);

	Nan::SetPrototypeMethod(tpl, "GetAnnotationTextProperty", GetAnnotationTextProperty);
	Nan::SetPrototypeMethod(tpl, "getAnnotationTextProperty", GetAnnotationTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetAnnotationTextScaling", GetAnnotationTextScaling);
	Nan::SetPrototypeMethod(tpl, "getAnnotationTextScaling", GetAnnotationTextScaling);

	Nan::SetPrototypeMethod(tpl, "GetBackgroundProperty", GetBackgroundProperty);
	Nan::SetPrototypeMethod(tpl, "getBackgroundProperty", GetBackgroundProperty);

	Nan::SetPrototypeMethod(tpl, "GetBarRatio", GetBarRatio);
	Nan::SetPrototypeMethod(tpl, "getBarRatio", GetBarRatio);

	Nan::SetPrototypeMethod(tpl, "GetBarRatioMaxValue", GetBarRatioMaxValue);
	Nan::SetPrototypeMethod(tpl, "getBarRatioMaxValue", GetBarRatioMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetBarRatioMinValue", GetBarRatioMinValue);
	Nan::SetPrototypeMethod(tpl, "getBarRatioMinValue", GetBarRatioMinValue);

	Nan::SetPrototypeMethod(tpl, "GetBelowRangeAnnotation", GetBelowRangeAnnotation);
	Nan::SetPrototypeMethod(tpl, "getBelowRangeAnnotation", GetBelowRangeAnnotation);

	Nan::SetPrototypeMethod(tpl, "GetComponentTitle", GetComponentTitle);
	Nan::SetPrototypeMethod(tpl, "getComponentTitle", GetComponentTitle);

	Nan::SetPrototypeMethod(tpl, "GetDrawAboveRangeSwatch", GetDrawAboveRangeSwatch);
	Nan::SetPrototypeMethod(tpl, "getDrawAboveRangeSwatch", GetDrawAboveRangeSwatch);

	Nan::SetPrototypeMethod(tpl, "GetDrawAnnotations", GetDrawAnnotations);
	Nan::SetPrototypeMethod(tpl, "getDrawAnnotations", GetDrawAnnotations);

	Nan::SetPrototypeMethod(tpl, "GetDrawBackground", GetDrawBackground);
	Nan::SetPrototypeMethod(tpl, "getDrawBackground", GetDrawBackground);

	Nan::SetPrototypeMethod(tpl, "GetDrawBelowRangeSwatch", GetDrawBelowRangeSwatch);
	Nan::SetPrototypeMethod(tpl, "getDrawBelowRangeSwatch", GetDrawBelowRangeSwatch);

	Nan::SetPrototypeMethod(tpl, "GetDrawColorBar", GetDrawColorBar);
	Nan::SetPrototypeMethod(tpl, "getDrawColorBar", GetDrawColorBar);

	Nan::SetPrototypeMethod(tpl, "GetDrawFrame", GetDrawFrame);
	Nan::SetPrototypeMethod(tpl, "getDrawFrame", GetDrawFrame);

	Nan::SetPrototypeMethod(tpl, "GetDrawNanAnnotation", GetDrawNanAnnotation);
	Nan::SetPrototypeMethod(tpl, "getDrawNanAnnotation", GetDrawNanAnnotation);

	Nan::SetPrototypeMethod(tpl, "GetDrawTickLabels", GetDrawTickLabels);
	Nan::SetPrototypeMethod(tpl, "getDrawTickLabels", GetDrawTickLabels);

	Nan::SetPrototypeMethod(tpl, "GetFixedAnnotationLeaderLineColor", GetFixedAnnotationLeaderLineColor);
	Nan::SetPrototypeMethod(tpl, "getFixedAnnotationLeaderLineColor", GetFixedAnnotationLeaderLineColor);

	Nan::SetPrototypeMethod(tpl, "GetFrameProperty", GetFrameProperty);
	Nan::SetPrototypeMethod(tpl, "getFrameProperty", GetFrameProperty);

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

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

	Nan::SetPrototypeMethod(tpl, "GetLookupTable", GetLookupTable);
	Nan::SetPrototypeMethod(tpl, "getLookupTable", GetLookupTable);

	Nan::SetPrototypeMethod(tpl, "GetMaximumHeightInPixels", GetMaximumHeightInPixels);
	Nan::SetPrototypeMethod(tpl, "getMaximumHeightInPixels", GetMaximumHeightInPixels);

	Nan::SetPrototypeMethod(tpl, "GetMaximumNumberOfColors", GetMaximumNumberOfColors);
	Nan::SetPrototypeMethod(tpl, "getMaximumNumberOfColors", GetMaximumNumberOfColors);

	Nan::SetPrototypeMethod(tpl, "GetMaximumNumberOfColorsMaxValue", GetMaximumNumberOfColorsMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMaximumNumberOfColorsMaxValue", GetMaximumNumberOfColorsMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMaximumNumberOfColorsMinValue", GetMaximumNumberOfColorsMinValue);
	Nan::SetPrototypeMethod(tpl, "getMaximumNumberOfColorsMinValue", GetMaximumNumberOfColorsMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMaximumWidthInPixels", GetMaximumWidthInPixels);
	Nan::SetPrototypeMethod(tpl, "getMaximumWidthInPixels", GetMaximumWidthInPixels);

	Nan::SetPrototypeMethod(tpl, "GetNanAnnotation", GetNanAnnotation);
	Nan::SetPrototypeMethod(tpl, "getNanAnnotation", GetNanAnnotation);

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

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

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

	Nan::SetPrototypeMethod(tpl, "GetOrientation", GetOrientation);
	Nan::SetPrototypeMethod(tpl, "getOrientation", GetOrientation);

	Nan::SetPrototypeMethod(tpl, "GetOrientationMaxValue", GetOrientationMaxValue);
	Nan::SetPrototypeMethod(tpl, "getOrientationMaxValue", GetOrientationMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetOrientationMinValue", GetOrientationMinValue);
	Nan::SetPrototypeMethod(tpl, "getOrientationMinValue", GetOrientationMinValue);

	Nan::SetPrototypeMethod(tpl, "GetScalarBarRect", GetScalarBarRect);
	Nan::SetPrototypeMethod(tpl, "getScalarBarRect", GetScalarBarRect);

	Nan::SetPrototypeMethod(tpl, "GetTextPad", GetTextPad);
	Nan::SetPrototypeMethod(tpl, "getTextPad", GetTextPad);

	Nan::SetPrototypeMethod(tpl, "GetTextPosition", GetTextPosition);
	Nan::SetPrototypeMethod(tpl, "getTextPosition", GetTextPosition);

	Nan::SetPrototypeMethod(tpl, "GetTextPositionMaxValue", GetTextPositionMaxValue);
	Nan::SetPrototypeMethod(tpl, "getTextPositionMaxValue", GetTextPositionMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetTextPositionMinValue", GetTextPositionMinValue);
	Nan::SetPrototypeMethod(tpl, "getTextPositionMinValue", GetTextPositionMinValue);

	Nan::SetPrototypeMethod(tpl, "GetTextureActor", GetTextureActor);
	Nan::SetPrototypeMethod(tpl, "getTextureActor", GetTextureActor);

	Nan::SetPrototypeMethod(tpl, "GetTextureGridWidth", GetTextureGridWidth);
	Nan::SetPrototypeMethod(tpl, "getTextureGridWidth", GetTextureGridWidth);

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

	Nan::SetPrototypeMethod(tpl, "GetTitleRatio", GetTitleRatio);
	Nan::SetPrototypeMethod(tpl, "getTitleRatio", GetTitleRatio);

	Nan::SetPrototypeMethod(tpl, "GetTitleRatioMaxValue", GetTitleRatioMaxValue);
	Nan::SetPrototypeMethod(tpl, "getTitleRatioMaxValue", GetTitleRatioMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetTitleRatioMinValue", GetTitleRatioMinValue);
	Nan::SetPrototypeMethod(tpl, "getTitleRatioMinValue", GetTitleRatioMinValue);

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

	Nan::SetPrototypeMethod(tpl, "GetUnconstrainedFontSize", GetUnconstrainedFontSize);
	Nan::SetPrototypeMethod(tpl, "getUnconstrainedFontSize", GetUnconstrainedFontSize);

	Nan::SetPrototypeMethod(tpl, "GetUseOpacity", GetUseOpacity);
	Nan::SetPrototypeMethod(tpl, "getUseOpacity", GetUseOpacity);

	Nan::SetPrototypeMethod(tpl, "GetVerticalTitleSeparation", GetVerticalTitleSeparation);
	Nan::SetPrototypeMethod(tpl, "getVerticalTitleSeparation", GetVerticalTitleSeparation);

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

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

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

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

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

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

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

	Nan::SetPrototypeMethod(tpl, "SetAboveRangeAnnotation", SetAboveRangeAnnotation);
	Nan::SetPrototypeMethod(tpl, "setAboveRangeAnnotation", SetAboveRangeAnnotation);

	Nan::SetPrototypeMethod(tpl, "SetAnnotationLeaderPadding", SetAnnotationLeaderPadding);
	Nan::SetPrototypeMethod(tpl, "setAnnotationLeaderPadding", SetAnnotationLeaderPadding);

	Nan::SetPrototypeMethod(tpl, "SetAnnotationTextProperty", SetAnnotationTextProperty);
	Nan::SetPrototypeMethod(tpl, "setAnnotationTextProperty", SetAnnotationTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetAnnotationTextScaling", SetAnnotationTextScaling);
	Nan::SetPrototypeMethod(tpl, "setAnnotationTextScaling", SetAnnotationTextScaling);

	Nan::SetPrototypeMethod(tpl, "SetBackgroundProperty", SetBackgroundProperty);
	Nan::SetPrototypeMethod(tpl, "setBackgroundProperty", SetBackgroundProperty);

	Nan::SetPrototypeMethod(tpl, "SetBarRatio", SetBarRatio);
	Nan::SetPrototypeMethod(tpl, "setBarRatio", SetBarRatio);

	Nan::SetPrototypeMethod(tpl, "SetBelowRangeAnnotation", SetBelowRangeAnnotation);
	Nan::SetPrototypeMethod(tpl, "setBelowRangeAnnotation", SetBelowRangeAnnotation);

	Nan::SetPrototypeMethod(tpl, "SetComponentTitle", SetComponentTitle);
	Nan::SetPrototypeMethod(tpl, "setComponentTitle", SetComponentTitle);

	Nan::SetPrototypeMethod(tpl, "SetDrawAboveRangeSwatch", SetDrawAboveRangeSwatch);
	Nan::SetPrototypeMethod(tpl, "setDrawAboveRangeSwatch", SetDrawAboveRangeSwatch);

	Nan::SetPrototypeMethod(tpl, "SetDrawAnnotations", SetDrawAnnotations);
	Nan::SetPrototypeMethod(tpl, "setDrawAnnotations", SetDrawAnnotations);

	Nan::SetPrototypeMethod(tpl, "SetDrawBackground", SetDrawBackground);
	Nan::SetPrototypeMethod(tpl, "setDrawBackground", SetDrawBackground);

	Nan::SetPrototypeMethod(tpl, "SetDrawBelowRangeSwatch", SetDrawBelowRangeSwatch);
	Nan::SetPrototypeMethod(tpl, "setDrawBelowRangeSwatch", SetDrawBelowRangeSwatch);

	Nan::SetPrototypeMethod(tpl, "SetDrawColorBar", SetDrawColorBar);
	Nan::SetPrototypeMethod(tpl, "setDrawColorBar", SetDrawColorBar);

	Nan::SetPrototypeMethod(tpl, "SetDrawFrame", SetDrawFrame);
	Nan::SetPrototypeMethod(tpl, "setDrawFrame", SetDrawFrame);

	Nan::SetPrototypeMethod(tpl, "SetDrawNanAnnotation", SetDrawNanAnnotation);
	Nan::SetPrototypeMethod(tpl, "setDrawNanAnnotation", SetDrawNanAnnotation);

	Nan::SetPrototypeMethod(tpl, "SetDrawTickLabels", SetDrawTickLabels);
	Nan::SetPrototypeMethod(tpl, "setDrawTickLabels", SetDrawTickLabels);

	Nan::SetPrototypeMethod(tpl, "SetFixedAnnotationLeaderLineColor", SetFixedAnnotationLeaderLineColor);
	Nan::SetPrototypeMethod(tpl, "setFixedAnnotationLeaderLineColor", SetFixedAnnotationLeaderLineColor);

	Nan::SetPrototypeMethod(tpl, "SetFrameProperty", SetFrameProperty);
	Nan::SetPrototypeMethod(tpl, "setFrameProperty", SetFrameProperty);

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

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

	Nan::SetPrototypeMethod(tpl, "SetLookupTable", SetLookupTable);
	Nan::SetPrototypeMethod(tpl, "setLookupTable", SetLookupTable);

	Nan::SetPrototypeMethod(tpl, "SetMaximumHeightInPixels", SetMaximumHeightInPixels);
	Nan::SetPrototypeMethod(tpl, "setMaximumHeightInPixels", SetMaximumHeightInPixels);

	Nan::SetPrototypeMethod(tpl, "SetMaximumNumberOfColors", SetMaximumNumberOfColors);
	Nan::SetPrototypeMethod(tpl, "setMaximumNumberOfColors", SetMaximumNumberOfColors);

	Nan::SetPrototypeMethod(tpl, "SetMaximumWidthInPixels", SetMaximumWidthInPixels);
	Nan::SetPrototypeMethod(tpl, "setMaximumWidthInPixels", SetMaximumWidthInPixels);

	Nan::SetPrototypeMethod(tpl, "SetNanAnnotation", SetNanAnnotation);
	Nan::SetPrototypeMethod(tpl, "setNanAnnotation", SetNanAnnotation);

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

	Nan::SetPrototypeMethod(tpl, "SetOrientation", SetOrientation);
	Nan::SetPrototypeMethod(tpl, "setOrientation", SetOrientation);

	Nan::SetPrototypeMethod(tpl, "SetOrientationToHorizontal", SetOrientationToHorizontal);
	Nan::SetPrototypeMethod(tpl, "setOrientationToHorizontal", SetOrientationToHorizontal);

	Nan::SetPrototypeMethod(tpl, "SetOrientationToVertical", SetOrientationToVertical);
	Nan::SetPrototypeMethod(tpl, "setOrientationToVertical", SetOrientationToVertical);

	Nan::SetPrototypeMethod(tpl, "SetTextPad", SetTextPad);
	Nan::SetPrototypeMethod(tpl, "setTextPad", SetTextPad);

	Nan::SetPrototypeMethod(tpl, "SetTextPosition", SetTextPosition);
	Nan::SetPrototypeMethod(tpl, "setTextPosition", SetTextPosition);

	Nan::SetPrototypeMethod(tpl, "SetTextPositionToPrecedeScalarBar", SetTextPositionToPrecedeScalarBar);
	Nan::SetPrototypeMethod(tpl, "setTextPositionToPrecedeScalarBar", SetTextPositionToPrecedeScalarBar);

	Nan::SetPrototypeMethod(tpl, "SetTextPositionToSucceedScalarBar", SetTextPositionToSucceedScalarBar);
	Nan::SetPrototypeMethod(tpl, "setTextPositionToSucceedScalarBar", SetTextPositionToSucceedScalarBar);

	Nan::SetPrototypeMethod(tpl, "SetTextureGridWidth", SetTextureGridWidth);
	Nan::SetPrototypeMethod(tpl, "setTextureGridWidth", SetTextureGridWidth);

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

	Nan::SetPrototypeMethod(tpl, "SetTitleRatio", SetTitleRatio);
	Nan::SetPrototypeMethod(tpl, "setTitleRatio", SetTitleRatio);

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

	Nan::SetPrototypeMethod(tpl, "SetUnconstrainedFontSize", SetUnconstrainedFontSize);
	Nan::SetPrototypeMethod(tpl, "setUnconstrainedFontSize", SetUnconstrainedFontSize);

	Nan::SetPrototypeMethod(tpl, "SetUseOpacity", SetUseOpacity);
	Nan::SetPrototypeMethod(tpl, "setUseOpacity", SetUseOpacity);

	Nan::SetPrototypeMethod(tpl, "SetVerticalTitleSeparation", SetVerticalTitleSeparation);
	Nan::SetPrototypeMethod(tpl, "setVerticalTitleSeparation", SetVerticalTitleSeparation);

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

	Nan::SetPrototypeMethod(tpl, "UnconstrainedFontSizeOff", UnconstrainedFontSizeOff);
	Nan::SetPrototypeMethod(tpl, "unconstrainedFontSizeOff", UnconstrainedFontSizeOff);

	Nan::SetPrototypeMethod(tpl, "UnconstrainedFontSizeOn", UnconstrainedFontSizeOn);
	Nan::SetPrototypeMethod(tpl, "unconstrainedFontSizeOn", UnconstrainedFontSizeOn);

	Nan::SetPrototypeMethod(tpl, "UseOpacityOff", UseOpacityOff);
	Nan::SetPrototypeMethod(tpl, "useOpacityOff", UseOpacityOff);

	Nan::SetPrototypeMethod(tpl, "UseOpacityOn", UseOpacityOn);
	Nan::SetPrototypeMethod(tpl, "useOpacityOn", UseOpacityOn);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[1]))
		{
			VtkViewportWrap *a1 = ObjectWrap::Unwrap<VtkViewportWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->GetScalarBarRect(
				(int *)(a0->Buffer()->GetContents().Data()),
				(vtkViewport *) a1->native.GetPointer()
			);
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		int b0[4];
		if( a0->Length() < 4 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 4; i++ )
		{
			if( !a0->Get(i)->IsInt32() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->Int32Value();
		}
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[1]))
		{
			VtkViewportWrap *a1 = ObjectWrap::Unwrap<VtkViewportWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->GetScalarBarRect(
				b0,
				(vtkViewport *) a1->native.GetPointer()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkScalarBarActorWrap::SetLabelFormat(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkScalarBarActorWrap *wrapper = ObjectWrap::Unwrap<VtkScalarBarActorWrap>(info.Holder());
	vtkScalarBarActor *native = (vtkScalarBarActor *)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 VtkScalarBarActorWrap::SetLabelTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkScalarBarActorWrap *wrapper = ObjectWrap::Unwrap<VtkScalarBarActorWrap>(info.Holder());
	vtkScalarBarActor *native = (vtkScalarBarActor *)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 VtkScalarBarActorWrap::SetLookupTable(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkScalarBarActorWrap *wrapper = ObjectWrap::Unwrap<VtkScalarBarActorWrap>(info.Holder());
	vtkScalarBarActor *native = (vtkScalarBarActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkScalarsToColorsWrap::ptpl))->HasInstance(info[0]))
	{
		VtkScalarsToColorsWrap *a0 = ObjectWrap::Unwrap<VtkScalarsToColorsWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLookupTable(
			(vtkScalarsToColors *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkScalarBarActorWrap::SetTitleTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkScalarBarActorWrap *wrapper = ObjectWrap::Unwrap<VtkScalarBarActorWrap>(info.Holder());
	vtkScalarBarActor *native = (vtkScalarBarActor *)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 VtkScalarBarActorWrap::SetUnconstrainedFontSize(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkScalarBarActorWrap *wrapper = ObjectWrap::Unwrap<VtkScalarBarActorWrap>(info.Holder());
	vtkScalarBarActor *native = (vtkScalarBarActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetUnconstrainedFontSize(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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