/* 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 "vtkXYPlotActorWrap.h"
#include "vtkObjectWrap.h"
#include "vtkDataSetWrap.h"
#include "vtkAlgorithmOutputWrap.h"
#include "vtkDataObjectWrap.h"
#include "vtkPolyDataWrap.h"
#include "vtkLegendBoxActorWrap.h"
#include "vtkGlyphSource2DWrap.h"
#include "vtkAxisActor2DWrap.h"
#include "vtkTextPropertyWrap.h"
#include "vtkViewportWrap.h"
#include "vtkProperty2DWrap.h"
#include "vtkWindowWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkXYPlotActorWrap::VtkXYPlotActorWrap()
{ }

VtkXYPlotActorWrap::VtkXYPlotActorWrap(vtkSmartPointer<vtkXYPlotActor> _native)
{ native = _native; }

VtkXYPlotActorWrap::~VtkXYPlotActorWrap()
{ }

void VtkXYPlotActorWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkXYPlotActor").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("XYPlotActor").ToLocalChecked(), ConstructorGetter);
}

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

void VtkXYPlotActorWrap::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("VtkXYPlotActorWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "AddDataObjectInput", AddDataObjectInput);
	Nan::SetPrototypeMethod(tpl, "addDataObjectInput", AddDataObjectInput);

	Nan::SetPrototypeMethod(tpl, "AddDataObjectInputConnection", AddDataObjectInputConnection);
	Nan::SetPrototypeMethod(tpl, "addDataObjectInputConnection", AddDataObjectInputConnection);

	Nan::SetPrototypeMethod(tpl, "AddDataSetInput", AddDataSetInput);
	Nan::SetPrototypeMethod(tpl, "addDataSetInput", AddDataSetInput);

	Nan::SetPrototypeMethod(tpl, "AddDataSetInputConnection", AddDataSetInputConnection);
	Nan::SetPrototypeMethod(tpl, "addDataSetInputConnection", AddDataSetInputConnection);

	Nan::SetPrototypeMethod(tpl, "AddUserCurvesPoint", AddUserCurvesPoint);
	Nan::SetPrototypeMethod(tpl, "addUserCurvesPoint", AddUserCurvesPoint);

	Nan::SetPrototypeMethod(tpl, "AdjustTitlePositionOff", AdjustTitlePositionOff);
	Nan::SetPrototypeMethod(tpl, "adjustTitlePositionOff", AdjustTitlePositionOff);

	Nan::SetPrototypeMethod(tpl, "AdjustTitlePositionOn", AdjustTitlePositionOn);
	Nan::SetPrototypeMethod(tpl, "adjustTitlePositionOn", AdjustTitlePositionOn);

	Nan::SetPrototypeMethod(tpl, "ChartBorderOff", ChartBorderOff);
	Nan::SetPrototypeMethod(tpl, "chartBorderOff", ChartBorderOff);

	Nan::SetPrototypeMethod(tpl, "ChartBorderOn", ChartBorderOn);
	Nan::SetPrototypeMethod(tpl, "chartBorderOn", ChartBorderOn);

	Nan::SetPrototypeMethod(tpl, "ChartBoxOff", ChartBoxOff);
	Nan::SetPrototypeMethod(tpl, "chartBoxOff", ChartBoxOff);

	Nan::SetPrototypeMethod(tpl, "ChartBoxOn", ChartBoxOn);
	Nan::SetPrototypeMethod(tpl, "chartBoxOn", ChartBoxOn);

	Nan::SetPrototypeMethod(tpl, "ExchangeAxesOff", ExchangeAxesOff);
	Nan::SetPrototypeMethod(tpl, "exchangeAxesOff", ExchangeAxesOff);

	Nan::SetPrototypeMethod(tpl, "ExchangeAxesOn", ExchangeAxesOn);
	Nan::SetPrototypeMethod(tpl, "exchangeAxesOn", ExchangeAxesOn);

	Nan::SetPrototypeMethod(tpl, "GetAdjustTitlePosition", GetAdjustTitlePosition);
	Nan::SetPrototypeMethod(tpl, "getAdjustTitlePosition", GetAdjustTitlePosition);

	Nan::SetPrototypeMethod(tpl, "GetAdjustTitlePositionMode", GetAdjustTitlePositionMode);
	Nan::SetPrototypeMethod(tpl, "getAdjustTitlePositionMode", GetAdjustTitlePositionMode);

	Nan::SetPrototypeMethod(tpl, "GetAdjustXLabels", GetAdjustXLabels);
	Nan::SetPrototypeMethod(tpl, "getAdjustXLabels", GetAdjustXLabels);

	Nan::SetPrototypeMethod(tpl, "GetAdjustYLabels", GetAdjustYLabels);
	Nan::SetPrototypeMethod(tpl, "getAdjustYLabels", GetAdjustYLabels);

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

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

	Nan::SetPrototypeMethod(tpl, "GetBorder", GetBorder);
	Nan::SetPrototypeMethod(tpl, "getBorder", GetBorder);

	Nan::SetPrototypeMethod(tpl, "GetBorderMaxValue", GetBorderMaxValue);
	Nan::SetPrototypeMethod(tpl, "getBorderMaxValue", GetBorderMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetBorderMinValue", GetBorderMinValue);
	Nan::SetPrototypeMethod(tpl, "getBorderMinValue", GetBorderMinValue);

	Nan::SetPrototypeMethod(tpl, "GetChartBorder", GetChartBorder);
	Nan::SetPrototypeMethod(tpl, "getChartBorder", GetChartBorder);

	Nan::SetPrototypeMethod(tpl, "GetChartBox", GetChartBox);
	Nan::SetPrototypeMethod(tpl, "getChartBox", GetChartBox);

	Nan::SetPrototypeMethod(tpl, "GetChartBoxProperty", GetChartBoxProperty);
	Nan::SetPrototypeMethod(tpl, "getChartBoxProperty", GetChartBoxProperty);

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

	Nan::SetPrototypeMethod(tpl, "GetDataObjectPlotMode", GetDataObjectPlotMode);
	Nan::SetPrototypeMethod(tpl, "getDataObjectPlotMode", GetDataObjectPlotMode);

	Nan::SetPrototypeMethod(tpl, "GetDataObjectPlotModeAsString", GetDataObjectPlotModeAsString);
	Nan::SetPrototypeMethod(tpl, "getDataObjectPlotModeAsString", GetDataObjectPlotModeAsString);

	Nan::SetPrototypeMethod(tpl, "GetDataObjectPlotModeMaxValue", GetDataObjectPlotModeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getDataObjectPlotModeMaxValue", GetDataObjectPlotModeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetDataObjectPlotModeMinValue", GetDataObjectPlotModeMinValue);
	Nan::SetPrototypeMethod(tpl, "getDataObjectPlotModeMinValue", GetDataObjectPlotModeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetDataObjectXComponent", GetDataObjectXComponent);
	Nan::SetPrototypeMethod(tpl, "getDataObjectXComponent", GetDataObjectXComponent);

	Nan::SetPrototypeMethod(tpl, "GetDataObjectYComponent", GetDataObjectYComponent);
	Nan::SetPrototypeMethod(tpl, "getDataObjectYComponent", GetDataObjectYComponent);

	Nan::SetPrototypeMethod(tpl, "GetExchangeAxes", GetExchangeAxes);
	Nan::SetPrototypeMethod(tpl, "getExchangeAxes", GetExchangeAxes);

	Nan::SetPrototypeMethod(tpl, "GetGlyphSize", GetGlyphSize);
	Nan::SetPrototypeMethod(tpl, "getGlyphSize", GetGlyphSize);

	Nan::SetPrototypeMethod(tpl, "GetGlyphSizeMaxValue", GetGlyphSizeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getGlyphSizeMaxValue", GetGlyphSizeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetGlyphSizeMinValue", GetGlyphSizeMinValue);
	Nan::SetPrototypeMethod(tpl, "getGlyphSizeMinValue", GetGlyphSizeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetGlyphSource", GetGlyphSource);
	Nan::SetPrototypeMethod(tpl, "getGlyphSource", GetGlyphSource);

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

	Nan::SetPrototypeMethod(tpl, "GetLegend", GetLegend);
	Nan::SetPrototypeMethod(tpl, "getLegend", GetLegend);

	Nan::SetPrototypeMethod(tpl, "GetLegendActor", GetLegendActor);
	Nan::SetPrototypeMethod(tpl, "getLegendActor", GetLegendActor);

	Nan::SetPrototypeMethod(tpl, "GetLegendPosition", GetLegendPosition);
	Nan::SetPrototypeMethod(tpl, "getLegendPosition", GetLegendPosition);

	Nan::SetPrototypeMethod(tpl, "GetLegendPosition2", GetLegendPosition2);
	Nan::SetPrototypeMethod(tpl, "getLegendPosition2", GetLegendPosition2);

	Nan::SetPrototypeMethod(tpl, "GetLogx", GetLogx);
	Nan::SetPrototypeMethod(tpl, "getLogx", GetLogx);

	Nan::SetPrototypeMethod(tpl, "GetMTime", GetMTime);
	Nan::SetPrototypeMethod(tpl, "getMTime", GetMTime);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfXLabels", GetNumberOfXLabels);
	Nan::SetPrototypeMethod(tpl, "getNumberOfXLabels", GetNumberOfXLabels);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfXLabelsMaxValue", GetNumberOfXLabelsMaxValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfXLabelsMaxValue", GetNumberOfXLabelsMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfXLabelsMinValue", GetNumberOfXLabelsMinValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfXLabelsMinValue", GetNumberOfXLabelsMinValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfXMinorTicks", GetNumberOfXMinorTicks);
	Nan::SetPrototypeMethod(tpl, "getNumberOfXMinorTicks", GetNumberOfXMinorTicks);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfYLabels", GetNumberOfYLabels);
	Nan::SetPrototypeMethod(tpl, "getNumberOfYLabels", GetNumberOfYLabels);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfYLabelsMaxValue", GetNumberOfYLabelsMaxValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfYLabelsMaxValue", GetNumberOfYLabelsMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfYLabelsMinValue", GetNumberOfYLabelsMinValue);
	Nan::SetPrototypeMethod(tpl, "getNumberOfYLabelsMinValue", GetNumberOfYLabelsMinValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfYMinorTicks", GetNumberOfYMinorTicks);
	Nan::SetPrototypeMethod(tpl, "getNumberOfYMinorTicks", GetNumberOfYMinorTicks);

	Nan::SetPrototypeMethod(tpl, "GetPlotColor", GetPlotColor);
	Nan::SetPrototypeMethod(tpl, "getPlotColor", GetPlotColor);

	Nan::SetPrototypeMethod(tpl, "GetPlotCoordinate", GetPlotCoordinate);
	Nan::SetPrototypeMethod(tpl, "getPlotCoordinate", GetPlotCoordinate);

	Nan::SetPrototypeMethod(tpl, "GetPlotCurveLines", GetPlotCurveLines);
	Nan::SetPrototypeMethod(tpl, "getPlotCurveLines", GetPlotCurveLines);

	Nan::SetPrototypeMethod(tpl, "GetPlotCurvePoints", GetPlotCurvePoints);
	Nan::SetPrototypeMethod(tpl, "getPlotCurvePoints", GetPlotCurvePoints);

	Nan::SetPrototypeMethod(tpl, "GetPlotLabel", GetPlotLabel);
	Nan::SetPrototypeMethod(tpl, "getPlotLabel", GetPlotLabel);

	Nan::SetPrototypeMethod(tpl, "GetPlotLines", GetPlotLines);
	Nan::SetPrototypeMethod(tpl, "getPlotLines", GetPlotLines);

	Nan::SetPrototypeMethod(tpl, "GetPlotPoints", GetPlotPoints);
	Nan::SetPrototypeMethod(tpl, "getPlotPoints", GetPlotPoints);

	Nan::SetPrototypeMethod(tpl, "GetPlotSymbol", GetPlotSymbol);
	Nan::SetPrototypeMethod(tpl, "getPlotSymbol", GetPlotSymbol);

	Nan::SetPrototypeMethod(tpl, "GetPointComponent", GetPointComponent);
	Nan::SetPrototypeMethod(tpl, "getPointComponent", GetPointComponent);

	Nan::SetPrototypeMethod(tpl, "GetReferenceXValue", GetReferenceXValue);
	Nan::SetPrototypeMethod(tpl, "getReferenceXValue", GetReferenceXValue);

	Nan::SetPrototypeMethod(tpl, "GetReferenceYValue", GetReferenceYValue);
	Nan::SetPrototypeMethod(tpl, "getReferenceYValue", GetReferenceYValue);

	Nan::SetPrototypeMethod(tpl, "GetReverseXAxis", GetReverseXAxis);
	Nan::SetPrototypeMethod(tpl, "getReverseXAxis", GetReverseXAxis);

	Nan::SetPrototypeMethod(tpl, "GetReverseYAxis", GetReverseYAxis);
	Nan::SetPrototypeMethod(tpl, "getReverseYAxis", GetReverseYAxis);

	Nan::SetPrototypeMethod(tpl, "GetShowReferenceXLine", GetShowReferenceXLine);
	Nan::SetPrototypeMethod(tpl, "getShowReferenceXLine", GetShowReferenceXLine);

	Nan::SetPrototypeMethod(tpl, "GetShowReferenceYLine", GetShowReferenceYLine);
	Nan::SetPrototypeMethod(tpl, "getShowReferenceYLine", GetShowReferenceYLine);

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

	Nan::SetPrototypeMethod(tpl, "GetTitlePosition", GetTitlePosition);
	Nan::SetPrototypeMethod(tpl, "getTitlePosition", GetTitlePosition);

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

	Nan::SetPrototypeMethod(tpl, "GetViewportCoordinate", GetViewportCoordinate);
	Nan::SetPrototypeMethod(tpl, "getViewportCoordinate", GetViewportCoordinate);

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

	Nan::SetPrototypeMethod(tpl, "GetXLabelFormat", GetXLabelFormat);
	Nan::SetPrototypeMethod(tpl, "getXLabelFormat", GetXLabelFormat);

	Nan::SetPrototypeMethod(tpl, "GetXRange", GetXRange);
	Nan::SetPrototypeMethod(tpl, "getXRange", GetXRange);

	Nan::SetPrototypeMethod(tpl, "GetXTitle", GetXTitle);
	Nan::SetPrototypeMethod(tpl, "getXTitle", GetXTitle);

	Nan::SetPrototypeMethod(tpl, "GetXTitlePosition", GetXTitlePosition);
	Nan::SetPrototypeMethod(tpl, "getXTitlePosition", GetXTitlePosition);

	Nan::SetPrototypeMethod(tpl, "GetXValues", GetXValues);
	Nan::SetPrototypeMethod(tpl, "getXValues", GetXValues);

	Nan::SetPrototypeMethod(tpl, "GetXValuesAsString", GetXValuesAsString);
	Nan::SetPrototypeMethod(tpl, "getXValuesAsString", GetXValuesAsString);

	Nan::SetPrototypeMethod(tpl, "GetXValuesMaxValue", GetXValuesMaxValue);
	Nan::SetPrototypeMethod(tpl, "getXValuesMaxValue", GetXValuesMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetXValuesMinValue", GetXValuesMinValue);
	Nan::SetPrototypeMethod(tpl, "getXValuesMinValue", GetXValuesMinValue);

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

	Nan::SetPrototypeMethod(tpl, "GetYLabelFormat", GetYLabelFormat);
	Nan::SetPrototypeMethod(tpl, "getYLabelFormat", GetYLabelFormat);

	Nan::SetPrototypeMethod(tpl, "GetYRange", GetYRange);
	Nan::SetPrototypeMethod(tpl, "getYRange", GetYRange);

	Nan::SetPrototypeMethod(tpl, "GetYTitle", GetYTitle);
	Nan::SetPrototypeMethod(tpl, "getYTitle", GetYTitle);

	Nan::SetPrototypeMethod(tpl, "GetYTitlePosition", GetYTitlePosition);
	Nan::SetPrototypeMethod(tpl, "getYTitlePosition", GetYTitlePosition);

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

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

	Nan::SetPrototypeMethod(tpl, "IsInPlot", IsInPlot);
	Nan::SetPrototypeMethod(tpl, "isInPlot", IsInPlot);

	Nan::SetPrototypeMethod(tpl, "LegendOff", LegendOff);
	Nan::SetPrototypeMethod(tpl, "legendOff", LegendOff);

	Nan::SetPrototypeMethod(tpl, "LegendOn", LegendOn);
	Nan::SetPrototypeMethod(tpl, "legendOn", LegendOn);

	Nan::SetPrototypeMethod(tpl, "LogxOff", LogxOff);
	Nan::SetPrototypeMethod(tpl, "logxOff", LogxOff);

	Nan::SetPrototypeMethod(tpl, "LogxOn", LogxOn);
	Nan::SetPrototypeMethod(tpl, "logxOn", LogxOn);

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

	Nan::SetPrototypeMethod(tpl, "PlotCurveLinesOff", PlotCurveLinesOff);
	Nan::SetPrototypeMethod(tpl, "plotCurveLinesOff", PlotCurveLinesOff);

	Nan::SetPrototypeMethod(tpl, "PlotCurveLinesOn", PlotCurveLinesOn);
	Nan::SetPrototypeMethod(tpl, "plotCurveLinesOn", PlotCurveLinesOn);

	Nan::SetPrototypeMethod(tpl, "PlotCurvePointsOff", PlotCurvePointsOff);
	Nan::SetPrototypeMethod(tpl, "plotCurvePointsOff", PlotCurvePointsOff);

	Nan::SetPrototypeMethod(tpl, "PlotCurvePointsOn", PlotCurvePointsOn);
	Nan::SetPrototypeMethod(tpl, "plotCurvePointsOn", PlotCurvePointsOn);

	Nan::SetPrototypeMethod(tpl, "PlotLinesOff", PlotLinesOff);
	Nan::SetPrototypeMethod(tpl, "plotLinesOff", PlotLinesOff);

	Nan::SetPrototypeMethod(tpl, "PlotLinesOn", PlotLinesOn);
	Nan::SetPrototypeMethod(tpl, "plotLinesOn", PlotLinesOn);

	Nan::SetPrototypeMethod(tpl, "PlotPointsOff", PlotPointsOff);
	Nan::SetPrototypeMethod(tpl, "plotPointsOff", PlotPointsOff);

	Nan::SetPrototypeMethod(tpl, "PlotPointsOn", PlotPointsOn);
	Nan::SetPrototypeMethod(tpl, "plotPointsOn", PlotPointsOn);

	Nan::SetPrototypeMethod(tpl, "PlotToViewportCoordinate", PlotToViewportCoordinate);
	Nan::SetPrototypeMethod(tpl, "plotToViewportCoordinate", PlotToViewportCoordinate);

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

	Nan::SetPrototypeMethod(tpl, "RemoveAllActiveCurves", RemoveAllActiveCurves);
	Nan::SetPrototypeMethod(tpl, "removeAllActiveCurves", RemoveAllActiveCurves);

	Nan::SetPrototypeMethod(tpl, "RemoveAllDataSetInputConnections", RemoveAllDataSetInputConnections);
	Nan::SetPrototypeMethod(tpl, "removeAllDataSetInputConnections", RemoveAllDataSetInputConnections);

	Nan::SetPrototypeMethod(tpl, "RemoveDataObjectInput", RemoveDataObjectInput);
	Nan::SetPrototypeMethod(tpl, "removeDataObjectInput", RemoveDataObjectInput);

	Nan::SetPrototypeMethod(tpl, "RemoveDataObjectInputConnection", RemoveDataObjectInputConnection);
	Nan::SetPrototypeMethod(tpl, "removeDataObjectInputConnection", RemoveDataObjectInputConnection);

	Nan::SetPrototypeMethod(tpl, "RemoveDataSetInput", RemoveDataSetInput);
	Nan::SetPrototypeMethod(tpl, "removeDataSetInput", RemoveDataSetInput);

	Nan::SetPrototypeMethod(tpl, "RemoveDataSetInputConnection", RemoveDataSetInputConnection);
	Nan::SetPrototypeMethod(tpl, "removeDataSetInputConnection", RemoveDataSetInputConnection);

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

	Nan::SetPrototypeMethod(tpl, "ReverseXAxisOn", ReverseXAxisOn);
	Nan::SetPrototypeMethod(tpl, "reverseXAxisOn", ReverseXAxisOn);

	Nan::SetPrototypeMethod(tpl, "ReverseYAxisOff", ReverseYAxisOff);
	Nan::SetPrototypeMethod(tpl, "reverseYAxisOff", ReverseYAxisOff);

	Nan::SetPrototypeMethod(tpl, "ReverseYAxisOn", ReverseYAxisOn);
	Nan::SetPrototypeMethod(tpl, "reverseYAxisOn", ReverseYAxisOn);

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

	Nan::SetPrototypeMethod(tpl, "SetAdjustTitlePosition", SetAdjustTitlePosition);
	Nan::SetPrototypeMethod(tpl, "setAdjustTitlePosition", SetAdjustTitlePosition);

	Nan::SetPrototypeMethod(tpl, "SetAdjustTitlePositionMode", SetAdjustTitlePositionMode);
	Nan::SetPrototypeMethod(tpl, "setAdjustTitlePositionMode", SetAdjustTitlePositionMode);

	Nan::SetPrototypeMethod(tpl, "SetAdjustXLabels", SetAdjustXLabels);
	Nan::SetPrototypeMethod(tpl, "setAdjustXLabels", SetAdjustXLabels);

	Nan::SetPrototypeMethod(tpl, "SetAdjustYLabels", SetAdjustYLabels);
	Nan::SetPrototypeMethod(tpl, "setAdjustYLabels", SetAdjustYLabels);

	Nan::SetPrototypeMethod(tpl, "SetAxisLabelBold", SetAxisLabelBold);
	Nan::SetPrototypeMethod(tpl, "setAxisLabelBold", SetAxisLabelBold);

	Nan::SetPrototypeMethod(tpl, "SetAxisLabelColor", SetAxisLabelColor);
	Nan::SetPrototypeMethod(tpl, "setAxisLabelColor", SetAxisLabelColor);

	Nan::SetPrototypeMethod(tpl, "SetAxisLabelFontFamily", SetAxisLabelFontFamily);
	Nan::SetPrototypeMethod(tpl, "setAxisLabelFontFamily", SetAxisLabelFontFamily);

	Nan::SetPrototypeMethod(tpl, "SetAxisLabelFontSize", SetAxisLabelFontSize);
	Nan::SetPrototypeMethod(tpl, "setAxisLabelFontSize", SetAxisLabelFontSize);

	Nan::SetPrototypeMethod(tpl, "SetAxisLabelItalic", SetAxisLabelItalic);
	Nan::SetPrototypeMethod(tpl, "setAxisLabelItalic", SetAxisLabelItalic);

	Nan::SetPrototypeMethod(tpl, "SetAxisLabelJustification", SetAxisLabelJustification);
	Nan::SetPrototypeMethod(tpl, "setAxisLabelJustification", SetAxisLabelJustification);

	Nan::SetPrototypeMethod(tpl, "SetAxisLabelShadow", SetAxisLabelShadow);
	Nan::SetPrototypeMethod(tpl, "setAxisLabelShadow", SetAxisLabelShadow);

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

	Nan::SetPrototypeMethod(tpl, "SetAxisLabelVerticalJustification", SetAxisLabelVerticalJustification);
	Nan::SetPrototypeMethod(tpl, "setAxisLabelVerticalJustification", SetAxisLabelVerticalJustification);

	Nan::SetPrototypeMethod(tpl, "SetAxisTitleBold", SetAxisTitleBold);
	Nan::SetPrototypeMethod(tpl, "setAxisTitleBold", SetAxisTitleBold);

	Nan::SetPrototypeMethod(tpl, "SetAxisTitleColor", SetAxisTitleColor);
	Nan::SetPrototypeMethod(tpl, "setAxisTitleColor", SetAxisTitleColor);

	Nan::SetPrototypeMethod(tpl, "SetAxisTitleFontFamily", SetAxisTitleFontFamily);
	Nan::SetPrototypeMethod(tpl, "setAxisTitleFontFamily", SetAxisTitleFontFamily);

	Nan::SetPrototypeMethod(tpl, "SetAxisTitleFontSize", SetAxisTitleFontSize);
	Nan::SetPrototypeMethod(tpl, "setAxisTitleFontSize", SetAxisTitleFontSize);

	Nan::SetPrototypeMethod(tpl, "SetAxisTitleItalic", SetAxisTitleItalic);
	Nan::SetPrototypeMethod(tpl, "setAxisTitleItalic", SetAxisTitleItalic);

	Nan::SetPrototypeMethod(tpl, "SetAxisTitleJustification", SetAxisTitleJustification);
	Nan::SetPrototypeMethod(tpl, "setAxisTitleJustification", SetAxisTitleJustification);

	Nan::SetPrototypeMethod(tpl, "SetAxisTitleShadow", SetAxisTitleShadow);
	Nan::SetPrototypeMethod(tpl, "setAxisTitleShadow", SetAxisTitleShadow);

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

	Nan::SetPrototypeMethod(tpl, "SetAxisTitleVerticalJustification", SetAxisTitleVerticalJustification);
	Nan::SetPrototypeMethod(tpl, "setAxisTitleVerticalJustification", SetAxisTitleVerticalJustification);

	Nan::SetPrototypeMethod(tpl, "SetBorder", SetBorder);
	Nan::SetPrototypeMethod(tpl, "setBorder", SetBorder);

	Nan::SetPrototypeMethod(tpl, "SetChartBorder", SetChartBorder);
	Nan::SetPrototypeMethod(tpl, "setChartBorder", SetChartBorder);

	Nan::SetPrototypeMethod(tpl, "SetChartBox", SetChartBox);
	Nan::SetPrototypeMethod(tpl, "setChartBox", SetChartBox);

	Nan::SetPrototypeMethod(tpl, "SetDataObjectPlotMode", SetDataObjectPlotMode);
	Nan::SetPrototypeMethod(tpl, "setDataObjectPlotMode", SetDataObjectPlotMode);

	Nan::SetPrototypeMethod(tpl, "SetDataObjectPlotModeToColumns", SetDataObjectPlotModeToColumns);
	Nan::SetPrototypeMethod(tpl, "setDataObjectPlotModeToColumns", SetDataObjectPlotModeToColumns);

	Nan::SetPrototypeMethod(tpl, "SetDataObjectPlotModeToRows", SetDataObjectPlotModeToRows);
	Nan::SetPrototypeMethod(tpl, "setDataObjectPlotModeToRows", SetDataObjectPlotModeToRows);

	Nan::SetPrototypeMethod(tpl, "SetDataObjectXComponent", SetDataObjectXComponent);
	Nan::SetPrototypeMethod(tpl, "setDataObjectXComponent", SetDataObjectXComponent);

	Nan::SetPrototypeMethod(tpl, "SetDataObjectYComponent", SetDataObjectYComponent);
	Nan::SetPrototypeMethod(tpl, "setDataObjectYComponent", SetDataObjectYComponent);

	Nan::SetPrototypeMethod(tpl, "SetExchangeAxes", SetExchangeAxes);
	Nan::SetPrototypeMethod(tpl, "setExchangeAxes", SetExchangeAxes);

	Nan::SetPrototypeMethod(tpl, "SetGlyphSize", SetGlyphSize);
	Nan::SetPrototypeMethod(tpl, "setGlyphSize", SetGlyphSize);

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

	Nan::SetPrototypeMethod(tpl, "SetLegend", SetLegend);
	Nan::SetPrototypeMethod(tpl, "setLegend", SetLegend);

	Nan::SetPrototypeMethod(tpl, "SetLegendBackgroundColor", SetLegendBackgroundColor);
	Nan::SetPrototypeMethod(tpl, "setLegendBackgroundColor", SetLegendBackgroundColor);

	Nan::SetPrototypeMethod(tpl, "SetLegendBorder", SetLegendBorder);
	Nan::SetPrototypeMethod(tpl, "setLegendBorder", SetLegendBorder);

	Nan::SetPrototypeMethod(tpl, "SetLegendBox", SetLegendBox);
	Nan::SetPrototypeMethod(tpl, "setLegendBox", SetLegendBox);

	Nan::SetPrototypeMethod(tpl, "SetLegendPosition", SetLegendPosition);
	Nan::SetPrototypeMethod(tpl, "setLegendPosition", SetLegendPosition);

	Nan::SetPrototypeMethod(tpl, "SetLegendPosition2", SetLegendPosition2);
	Nan::SetPrototypeMethod(tpl, "setLegendPosition2", SetLegendPosition2);

	Nan::SetPrototypeMethod(tpl, "SetLegendUseBackground", SetLegendUseBackground);
	Nan::SetPrototypeMethod(tpl, "setLegendUseBackground", SetLegendUseBackground);

	Nan::SetPrototypeMethod(tpl, "SetLineWidth", SetLineWidth);
	Nan::SetPrototypeMethod(tpl, "setLineWidth", SetLineWidth);

	Nan::SetPrototypeMethod(tpl, "SetLogx", SetLogx);
	Nan::SetPrototypeMethod(tpl, "setLogx", SetLogx);

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

	Nan::SetPrototypeMethod(tpl, "SetNumberOfXLabels", SetNumberOfXLabels);
	Nan::SetPrototypeMethod(tpl, "setNumberOfXLabels", SetNumberOfXLabels);

	Nan::SetPrototypeMethod(tpl, "SetNumberOfXMinorTicks", SetNumberOfXMinorTicks);
	Nan::SetPrototypeMethod(tpl, "setNumberOfXMinorTicks", SetNumberOfXMinorTicks);

	Nan::SetPrototypeMethod(tpl, "SetNumberOfYLabels", SetNumberOfYLabels);
	Nan::SetPrototypeMethod(tpl, "setNumberOfYLabels", SetNumberOfYLabels);

	Nan::SetPrototypeMethod(tpl, "SetNumberOfYMinorTicks", SetNumberOfYMinorTicks);
	Nan::SetPrototypeMethod(tpl, "setNumberOfYMinorTicks", SetNumberOfYMinorTicks);

	Nan::SetPrototypeMethod(tpl, "SetPlotColor", SetPlotColor);
	Nan::SetPrototypeMethod(tpl, "setPlotColor", SetPlotColor);

	Nan::SetPrototypeMethod(tpl, "SetPlotCoordinate", SetPlotCoordinate);
	Nan::SetPrototypeMethod(tpl, "setPlotCoordinate", SetPlotCoordinate);

	Nan::SetPrototypeMethod(tpl, "SetPlotCurveLines", SetPlotCurveLines);
	Nan::SetPrototypeMethod(tpl, "setPlotCurveLines", SetPlotCurveLines);

	Nan::SetPrototypeMethod(tpl, "SetPlotCurvePoints", SetPlotCurvePoints);
	Nan::SetPrototypeMethod(tpl, "setPlotCurvePoints", SetPlotCurvePoints);

	Nan::SetPrototypeMethod(tpl, "SetPlotGlyphType", SetPlotGlyphType);
	Nan::SetPrototypeMethod(tpl, "setPlotGlyphType", SetPlotGlyphType);

	Nan::SetPrototypeMethod(tpl, "SetPlotLabel", SetPlotLabel);
	Nan::SetPrototypeMethod(tpl, "setPlotLabel", SetPlotLabel);

	Nan::SetPrototypeMethod(tpl, "SetPlotLines", SetPlotLines);
	Nan::SetPrototypeMethod(tpl, "setPlotLines", SetPlotLines);

	Nan::SetPrototypeMethod(tpl, "SetPlotPoints", SetPlotPoints);
	Nan::SetPrototypeMethod(tpl, "setPlotPoints", SetPlotPoints);

	Nan::SetPrototypeMethod(tpl, "SetPlotRange", SetPlotRange);
	Nan::SetPrototypeMethod(tpl, "setPlotRange", SetPlotRange);

	Nan::SetPrototypeMethod(tpl, "SetPlotSymbol", SetPlotSymbol);
	Nan::SetPrototypeMethod(tpl, "setPlotSymbol", SetPlotSymbol);

	Nan::SetPrototypeMethod(tpl, "SetPointComponent", SetPointComponent);
	Nan::SetPrototypeMethod(tpl, "setPointComponent", SetPointComponent);

	Nan::SetPrototypeMethod(tpl, "SetReferenceXValue", SetReferenceXValue);
	Nan::SetPrototypeMethod(tpl, "setReferenceXValue", SetReferenceXValue);

	Nan::SetPrototypeMethod(tpl, "SetReferenceYValue", SetReferenceYValue);
	Nan::SetPrototypeMethod(tpl, "setReferenceYValue", SetReferenceYValue);

	Nan::SetPrototypeMethod(tpl, "SetReverseXAxis", SetReverseXAxis);
	Nan::SetPrototypeMethod(tpl, "setReverseXAxis", SetReverseXAxis);

	Nan::SetPrototypeMethod(tpl, "SetReverseYAxis", SetReverseYAxis);
	Nan::SetPrototypeMethod(tpl, "setReverseYAxis", SetReverseYAxis);

	Nan::SetPrototypeMethod(tpl, "SetShowReferenceXLine", SetShowReferenceXLine);
	Nan::SetPrototypeMethod(tpl, "setShowReferenceXLine", SetShowReferenceXLine);

	Nan::SetPrototypeMethod(tpl, "SetShowReferenceYLine", SetShowReferenceYLine);
	Nan::SetPrototypeMethod(tpl, "setShowReferenceYLine", SetShowReferenceYLine);

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

	Nan::SetPrototypeMethod(tpl, "SetTitleBold", SetTitleBold);
	Nan::SetPrototypeMethod(tpl, "setTitleBold", SetTitleBold);

	Nan::SetPrototypeMethod(tpl, "SetTitleColor", SetTitleColor);
	Nan::SetPrototypeMethod(tpl, "setTitleColor", SetTitleColor);

	Nan::SetPrototypeMethod(tpl, "SetTitleFontFamily", SetTitleFontFamily);
	Nan::SetPrototypeMethod(tpl, "setTitleFontFamily", SetTitleFontFamily);

	Nan::SetPrototypeMethod(tpl, "SetTitleFontSize", SetTitleFontSize);
	Nan::SetPrototypeMethod(tpl, "setTitleFontSize", SetTitleFontSize);

	Nan::SetPrototypeMethod(tpl, "SetTitleItalic", SetTitleItalic);
	Nan::SetPrototypeMethod(tpl, "setTitleItalic", SetTitleItalic);

	Nan::SetPrototypeMethod(tpl, "SetTitleJustification", SetTitleJustification);
	Nan::SetPrototypeMethod(tpl, "setTitleJustification", SetTitleJustification);

	Nan::SetPrototypeMethod(tpl, "SetTitlePosition", SetTitlePosition);
	Nan::SetPrototypeMethod(tpl, "setTitlePosition", SetTitlePosition);

	Nan::SetPrototypeMethod(tpl, "SetTitleShadow", SetTitleShadow);
	Nan::SetPrototypeMethod(tpl, "setTitleShadow", SetTitleShadow);

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

	Nan::SetPrototypeMethod(tpl, "SetTitleVerticalJustification", SetTitleVerticalJustification);
	Nan::SetPrototypeMethod(tpl, "setTitleVerticalJustification", SetTitleVerticalJustification);

	Nan::SetPrototypeMethod(tpl, "SetViewportCoordinate", SetViewportCoordinate);
	Nan::SetPrototypeMethod(tpl, "setViewportCoordinate", SetViewportCoordinate);

	Nan::SetPrototypeMethod(tpl, "SetXAxisColor", SetXAxisColor);
	Nan::SetPrototypeMethod(tpl, "setXAxisColor", SetXAxisColor);

	Nan::SetPrototypeMethod(tpl, "SetXLabelFormat", SetXLabelFormat);
	Nan::SetPrototypeMethod(tpl, "setXLabelFormat", SetXLabelFormat);

	Nan::SetPrototypeMethod(tpl, "SetXRange", SetXRange);
	Nan::SetPrototypeMethod(tpl, "setXRange", SetXRange);

	Nan::SetPrototypeMethod(tpl, "SetXTitle", SetXTitle);
	Nan::SetPrototypeMethod(tpl, "setXTitle", SetXTitle);

	Nan::SetPrototypeMethod(tpl, "SetXTitlePosition", SetXTitlePosition);
	Nan::SetPrototypeMethod(tpl, "setXTitlePosition", SetXTitlePosition);

	Nan::SetPrototypeMethod(tpl, "SetXValues", SetXValues);
	Nan::SetPrototypeMethod(tpl, "setXValues", SetXValues);

	Nan::SetPrototypeMethod(tpl, "SetXValuesToArcLength", SetXValuesToArcLength);
	Nan::SetPrototypeMethod(tpl, "setXValuesToArcLength", SetXValuesToArcLength);

	Nan::SetPrototypeMethod(tpl, "SetXValuesToIndex", SetXValuesToIndex);
	Nan::SetPrototypeMethod(tpl, "setXValuesToIndex", SetXValuesToIndex);

	Nan::SetPrototypeMethod(tpl, "SetXValuesToNormalizedArcLength", SetXValuesToNormalizedArcLength);
	Nan::SetPrototypeMethod(tpl, "setXValuesToNormalizedArcLength", SetXValuesToNormalizedArcLength);

	Nan::SetPrototypeMethod(tpl, "SetXValuesToValue", SetXValuesToValue);
	Nan::SetPrototypeMethod(tpl, "setXValuesToValue", SetXValuesToValue);

	Nan::SetPrototypeMethod(tpl, "SetYAxisColor", SetYAxisColor);
	Nan::SetPrototypeMethod(tpl, "setYAxisColor", SetYAxisColor);

	Nan::SetPrototypeMethod(tpl, "SetYLabelFormat", SetYLabelFormat);
	Nan::SetPrototypeMethod(tpl, "setYLabelFormat", SetYLabelFormat);

	Nan::SetPrototypeMethod(tpl, "SetYRange", SetYRange);
	Nan::SetPrototypeMethod(tpl, "setYRange", SetYRange);

	Nan::SetPrototypeMethod(tpl, "SetYTitle", SetYTitle);
	Nan::SetPrototypeMethod(tpl, "setYTitle", SetYTitle);

	Nan::SetPrototypeMethod(tpl, "SetYTitlePosition", SetYTitlePosition);
	Nan::SetPrototypeMethod(tpl, "setYTitlePosition", SetYTitlePosition);

	Nan::SetPrototypeMethod(tpl, "SetYTitlePositionToHCenter", SetYTitlePositionToHCenter);
	Nan::SetPrototypeMethod(tpl, "setYTitlePositionToHCenter", SetYTitlePositionToHCenter);

	Nan::SetPrototypeMethod(tpl, "SetYTitlePositionToTop", SetYTitlePositionToTop);
	Nan::SetPrototypeMethod(tpl, "setYTitlePositionToTop", SetYTitlePositionToTop);

	Nan::SetPrototypeMethod(tpl, "SetYTitlePositionToVCenter", SetYTitlePositionToVCenter);
	Nan::SetPrototypeMethod(tpl, "setYTitlePositionToVCenter", SetYTitlePositionToVCenter);

	Nan::SetPrototypeMethod(tpl, "ShowReferenceXLineOff", ShowReferenceXLineOff);
	Nan::SetPrototypeMethod(tpl, "showReferenceXLineOff", ShowReferenceXLineOff);

	Nan::SetPrototypeMethod(tpl, "ShowReferenceXLineOn", ShowReferenceXLineOn);
	Nan::SetPrototypeMethod(tpl, "showReferenceXLineOn", ShowReferenceXLineOn);

	Nan::SetPrototypeMethod(tpl, "ShowReferenceYLineOff", ShowReferenceYLineOff);
	Nan::SetPrototypeMethod(tpl, "showReferenceYLineOff", ShowReferenceYLineOff);

	Nan::SetPrototypeMethod(tpl, "ShowReferenceYLineOn", ShowReferenceYLineOn);
	Nan::SetPrototypeMethod(tpl, "showReferenceYLineOn", ShowReferenceYLineOn);

	Nan::SetPrototypeMethod(tpl, "ViewportToPlotCoordinate", ViewportToPlotCoordinate);
	Nan::SetPrototypeMethod(tpl, "viewportToPlotCoordinate", ViewportToPlotCoordinate);

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

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

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

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

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

void VtkXYPlotActorWrap::AddDataSetInput(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkXYPlotActorWrap *wrapper = ObjectWrap::Unwrap<VtkXYPlotActorWrap>(info.Holder());
	vtkXYPlotActor *native = (vtkXYPlotActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataSetWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataSetWrap *a0 = ObjectWrap::Unwrap<VtkDataSetWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->AddDataSetInput(
					(vtkDataSet *) a0->native.GetPointer(),
					*a1,
					info[2]->Int32Value()
				);
				return;
			}
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->AddDataSetInput(
			(vtkDataSet *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkXYPlotActorWrap::AddDataSetInputConnection(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkXYPlotActorWrap *wrapper = ObjectWrap::Unwrap<VtkXYPlotActorWrap>(info.Holder());
	vtkXYPlotActor *native = (vtkXYPlotActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkAlgorithmOutputWrap::ptpl))->HasInstance(info[0]))
	{
		VtkAlgorithmOutputWrap *a0 = ObjectWrap::Unwrap<VtkAlgorithmOutputWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->AddDataSetInputConnection(
					(vtkAlgorithmOutput *) a0->native.GetPointer(),
					*a1,
					info[2]->Int32Value()
				);
				return;
			}
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->AddDataSetInputConnection(
			(vtkAlgorithmOutput *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkXYPlotActorWrap::RemoveDataSetInput(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkXYPlotActorWrap *wrapper = ObjectWrap::Unwrap<VtkXYPlotActorWrap>(info.Holder());
	vtkXYPlotActor *native = (vtkXYPlotActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataSetWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataSetWrap *a0 = ObjectWrap::Unwrap<VtkDataSetWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->RemoveDataSetInput(
					(vtkDataSet *) a0->native.GetPointer(),
					*a1,
					info[2]->Int32Value()
				);
				return;
			}
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->RemoveDataSetInput(
			(vtkDataSet *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkXYPlotActorWrap::RemoveDataSetInputConnection(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkXYPlotActorWrap *wrapper = ObjectWrap::Unwrap<VtkXYPlotActorWrap>(info.Holder());
	vtkXYPlotActor *native = (vtkXYPlotActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkAlgorithmOutputWrap::ptpl))->HasInstance(info[0]))
	{
		VtkAlgorithmOutputWrap *a0 = ObjectWrap::Unwrap<VtkAlgorithmOutputWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->RemoveDataSetInputConnection(
					(vtkAlgorithmOutput *) a0->native.GetPointer(),
					*a1,
					info[2]->Int32Value()
				);
				return;
			}
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->RemoveDataSetInputConnection(
			(vtkAlgorithmOutput *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkXYPlotActorWrap::SetPlotSymbol(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkXYPlotActorWrap *wrapper = ObjectWrap::Unwrap<VtkXYPlotActorWrap>(info.Holder());
	vtkXYPlotActor *native = (vtkXYPlotActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkPolyDataWrap::ptpl))->HasInstance(info[1]))
		{
			VtkPolyDataWrap *a1 = ObjectWrap::Unwrap<VtkPolyDataWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetPlotSymbol(
				info[0]->Int32Value(),
				(vtkPolyData *) a1->native.GetPointer()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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