text:
/* 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 "vtkProp3DWrap.h"
#include "vtkLODProp3DWrap.h"
#include "vtkObjectWrap.h"
#include "vtkMapperWrap.h"
#include "vtkPropertyWrap.h"
#include "vtkTextureWrap.h"
#include "vtkAbstractVolumeMapperWrap.h"
#include "vtkVolumePropertyWrap.h"
#include "vtkImageMapper3DWrap.h"
#include "vtkImagePropertyWrap.h"
#include "vtkAbstractMapper3DWrap.h"
#include "vtkPropCollectionWrap.h"
#include "vtkPropWrap.h"
#include "vtkViewportWrap.h"
#include "vtkWindowWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkLODProp3DWrap::VtkLODProp3DWrap()
{ }

VtkLODProp3DWrap::VtkLODProp3DWrap(vtkSmartPointer<vtkLODProp3D> _native)
{ native = _native; }

VtkLODProp3DWrap::~VtkLODProp3DWrap()
{ }

void VtkLODProp3DWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkLODProp3D").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("LODProp3D").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "AddEstimatedRenderTime", AddEstimatedRenderTime);
	Nan::SetPrototypeMethod(tpl, "addEstimatedRenderTime", AddEstimatedRenderTime);

	Nan::SetPrototypeMethod(tpl, "AddLOD", AddLOD);
	Nan::SetPrototypeMethod(tpl, "addLOD", AddLOD);

	Nan::SetPrototypeMethod(tpl, "AutomaticLODSelectionOff", AutomaticLODSelectionOff);
	Nan::SetPrototypeMethod(tpl, "automaticLODSelectionOff", AutomaticLODSelectionOff);

	Nan::SetPrototypeMethod(tpl, "AutomaticLODSelectionOn", AutomaticLODSelectionOn);
	Nan::SetPrototypeMethod(tpl, "automaticLODSelectionOn", AutomaticLODSelectionOn);

	Nan::SetPrototypeMethod(tpl, "AutomaticPickLODSelectionOff", AutomaticPickLODSelectionOff);
	Nan::SetPrototypeMethod(tpl, "automaticPickLODSelectionOff", AutomaticPickLODSelectionOff);

	Nan::SetPrototypeMethod(tpl, "AutomaticPickLODSelectionOn", AutomaticPickLODSelectionOn);
	Nan::SetPrototypeMethod(tpl, "automaticPickLODSelectionOn", AutomaticPickLODSelectionOn);

	Nan::SetPrototypeMethod(tpl, "DisableLOD", DisableLOD);
	Nan::SetPrototypeMethod(tpl, "disableLOD", DisableLOD);

	Nan::SetPrototypeMethod(tpl, "EnableLOD", EnableLOD);
	Nan::SetPrototypeMethod(tpl, "enableLOD", EnableLOD);

	Nan::SetPrototypeMethod(tpl, "GetActors", GetActors);
	Nan::SetPrototypeMethod(tpl, "getActors", GetActors);

	Nan::SetPrototypeMethod(tpl, "GetAutomaticLODSelection", GetAutomaticLODSelection);
	Nan::SetPrototypeMethod(tpl, "getAutomaticLODSelection", GetAutomaticLODSelection);

	Nan::SetPrototypeMethod(tpl, "GetAutomaticLODSelectionMaxValue", GetAutomaticLODSelectionMaxValue);
	Nan::SetPrototypeMethod(tpl, "getAutomaticLODSelectionMaxValue", GetAutomaticLODSelectionMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetAutomaticLODSelectionMinValue", GetAutomaticLODSelectionMinValue);
	Nan::SetPrototypeMethod(tpl, "getAutomaticLODSelectionMinValue", GetAutomaticLODSelectionMinValue);

	Nan::SetPrototypeMethod(tpl, "GetAutomaticPickLODSelection", GetAutomaticPickLODSelection);
	Nan::SetPrototypeMethod(tpl, "getAutomaticPickLODSelection", GetAutomaticPickLODSelection);

	Nan::SetPrototypeMethod(tpl, "GetAutomaticPickLODSelectionMaxValue", GetAutomaticPickLODSelectionMaxValue);
	Nan::SetPrototypeMethod(tpl, "getAutomaticPickLODSelectionMaxValue", GetAutomaticPickLODSelectionMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetAutomaticPickLODSelectionMinValue", GetAutomaticPickLODSelectionMinValue);
	Nan::SetPrototypeMethod(tpl, "getAutomaticPickLODSelectionMinValue", GetAutomaticPickLODSelectionMinValue);

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

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

	Nan::SetPrototypeMethod(tpl, "GetCurrentIndex", GetCurrentIndex);
	Nan::SetPrototypeMethod(tpl, "getCurrentIndex", GetCurrentIndex);

	Nan::SetPrototypeMethod(tpl, "GetLODEstimatedRenderTime", GetLODEstimatedRenderTime);
	Nan::SetPrototypeMethod(tpl, "getLODEstimatedRenderTime", GetLODEstimatedRenderTime);

	Nan::SetPrototypeMethod(tpl, "GetLODIndexEstimatedRenderTime", GetLODIndexEstimatedRenderTime);
	Nan::SetPrototypeMethod(tpl, "getLODIndexEstimatedRenderTime", GetLODIndexEstimatedRenderTime);

	Nan::SetPrototypeMethod(tpl, "GetLODIndexLevel", GetLODIndexLevel);
	Nan::SetPrototypeMethod(tpl, "getLODIndexLevel", GetLODIndexLevel);

	Nan::SetPrototypeMethod(tpl, "GetLODLevel", GetLODLevel);
	Nan::SetPrototypeMethod(tpl, "getLODLevel", GetLODLevel);

	Nan::SetPrototypeMethod(tpl, "GetLODMapper", GetLODMapper);
	Nan::SetPrototypeMethod(tpl, "getLODMapper", GetLODMapper);

	Nan::SetPrototypeMethod(tpl, "GetLastRenderedLODID", GetLastRenderedLODID);
	Nan::SetPrototypeMethod(tpl, "getLastRenderedLODID", GetLastRenderedLODID);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfLODs", GetNumberOfLODs);
	Nan::SetPrototypeMethod(tpl, "getNumberOfLODs", GetNumberOfLODs);

	Nan::SetPrototypeMethod(tpl, "GetPickLODID", GetPickLODID);
	Nan::SetPrototypeMethod(tpl, "getPickLODID", GetPickLODID);

	Nan::SetPrototypeMethod(tpl, "GetSelectedLODID", GetSelectedLODID);
	Nan::SetPrototypeMethod(tpl, "getSelectedLODID", GetSelectedLODID);

	Nan::SetPrototypeMethod(tpl, "GetSelectedPickLODID", GetSelectedPickLODID);
	Nan::SetPrototypeMethod(tpl, "getSelectedPickLODID", GetSelectedPickLODID);

	Nan::SetPrototypeMethod(tpl, "GetVolumes", GetVolumes);
	Nan::SetPrototypeMethod(tpl, "getVolumes", GetVolumes);

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

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

	Nan::SetPrototypeMethod(tpl, "IsLODEnabled", IsLODEnabled);
	Nan::SetPrototypeMethod(tpl, "isLODEnabled", IsLODEnabled);

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

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

	Nan::SetPrototypeMethod(tpl, "RemoveLOD", RemoveLOD);
	Nan::SetPrototypeMethod(tpl, "removeLOD", RemoveLOD);

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

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

	Nan::SetPrototypeMethod(tpl, "RenderVolumetricGeometry", RenderVolumetricGeometry);
	Nan::SetPrototypeMethod(tpl, "renderVolumetricGeometry", RenderVolumetricGeometry);

	Nan::SetPrototypeMethod(tpl, "RestoreEstimatedRenderTime", RestoreEstimatedRenderTime);
	Nan::SetPrototypeMethod(tpl, "restoreEstimatedRenderTime", RestoreEstimatedRenderTime);

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

	Nan::SetPrototypeMethod(tpl, "SetAllocatedRenderTime", SetAllocatedRenderTime);
	Nan::SetPrototypeMethod(tpl, "setAllocatedRenderTime", SetAllocatedRenderTime);

	Nan::SetPrototypeMethod(tpl, "SetAutomaticLODSelection", SetAutomaticLODSelection);
	Nan::SetPrototypeMethod(tpl, "setAutomaticLODSelection", SetAutomaticLODSelection);

	Nan::SetPrototypeMethod(tpl, "SetAutomaticPickLODSelection", SetAutomaticPickLODSelection);
	Nan::SetPrototypeMethod(tpl, "setAutomaticPickLODSelection", SetAutomaticPickLODSelection);

	Nan::SetPrototypeMethod(tpl, "SetLODBackfaceProperty", SetLODBackfaceProperty);
	Nan::SetPrototypeMethod(tpl, "setLODBackfaceProperty", SetLODBackfaceProperty);

	Nan::SetPrototypeMethod(tpl, "SetLODLevel", SetLODLevel);
	Nan::SetPrototypeMethod(tpl, "setLODLevel", SetLODLevel);

	Nan::SetPrototypeMethod(tpl, "SetLODMapper", SetLODMapper);
	Nan::SetPrototypeMethod(tpl, "setLODMapper", SetLODMapper);

	Nan::SetPrototypeMethod(tpl, "SetLODProperty", SetLODProperty);
	Nan::SetPrototypeMethod(tpl, "setLODProperty", SetLODProperty);

	Nan::SetPrototypeMethod(tpl, "SetLODTexture", SetLODTexture);
	Nan::SetPrototypeMethod(tpl, "setLODTexture", SetLODTexture);

	Nan::SetPrototypeMethod(tpl, "SetSelectedLODID", SetSelectedLODID);
	Nan::SetPrototypeMethod(tpl, "setSelectedLODID", SetSelectedLODID);

	Nan::SetPrototypeMethod(tpl, "SetSelectedPickLODID", SetSelectedPickLODID);
	Nan::SetPrototypeMethod(tpl, "setSelectedPickLODID", SetSelectedPickLODID);

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

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

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

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

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

void VtkLODProp3DWrap::AddLOD(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLODProp3DWrap *wrapper = ObjectWrap::Unwrap<VtkLODProp3DWrap>(info.Holder());
	vtkLODProp3D *native = (vtkLODProp3D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkMapperWrap::ptpl))->HasInstance(info[0]))
	{
		VtkMapperWrap *a0 = ObjectWrap::Unwrap<VtkMapperWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkPropertyWrap::ptpl))->HasInstance(info[1]))
		{
			VtkPropertyWrap *a1 = ObjectWrap::Unwrap<VtkPropertyWrap>(info[1]->ToObject());
			if(info.Length() > 2 && info[2]->IsObject() && (Nan::New(VtkPropertyWrap::ptpl))->HasInstance(info[2]))
			{
				VtkPropertyWrap *a2 = ObjectWrap::Unwrap<VtkPropertyWrap>(info[2]->ToObject());
				if(info.Length() > 3 && info[3]->IsObject() && (Nan::New(VtkTextureWrap::ptpl))->HasInstance(info[3]))
				{
					VtkTextureWrap *a3 = ObjectWrap::Unwrap<VtkTextureWrap>(info[3]->ToObject());
					if(info.Length() > 4 && info[4]->IsNumber())
					{
						int r;
						if(info.Length() != 5)
						{
							Nan::ThrowError("Too many parameters.");
							return;
						}
						r = native->AddLOD(
							(vtkMapper *) a0->native.GetPointer(),
							(vtkProperty *) a1->native.GetPointer(),
							(vtkProperty *) a2->native.GetPointer(),
							(vtkTexture *) a3->native.GetPointer(),
							info[4]->NumberValue()
						);
						info.GetReturnValue().Set(Nan::New(r));
						return;
					}
				}
				else if(info.Length() > 3 && info[3]->IsNumber())
				{
					int r;
					if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					r = native->AddLOD(
						(vtkMapper *) a0->native.GetPointer(),
						(vtkProperty *) a1->native.GetPointer(),
						(vtkProperty *) a2->native.GetPointer(),
						info[3]->NumberValue()
					);
					info.GetReturnValue().Set(Nan::New(r));
					return;
				}
			}
			else if(info.Length() > 2 && info[2]->IsObject() && (Nan::New(VtkTextureWrap::ptpl))->HasInstance(info[2]))
			{
				VtkTextureWrap *a2 = ObjectWrap::Unwrap<VtkTextureWrap>(info[2]->ToObject());
				if(info.Length() > 3 && info[3]->IsNumber())
				{
					int r;
					if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					r = native->AddLOD(
						(vtkMapper *) a0->native.GetPointer(),
						(vtkProperty *) a1->native.GetPointer(),
						(vtkTexture *) a2->native.GetPointer(),
						info[3]->NumberValue()
					);
					info.GetReturnValue().Set(Nan::New(r));
					return;
				}
			}
		}
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkImageMapper3DWrap::ptpl))->HasInstance(info[0]))
	{
		VtkImageMapper3DWrap *a0 = ObjectWrap::Unwrap<VtkImageMapper3DWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkImagePropertyWrap::ptpl))->HasInstance(info[1]))
		{
			VtkImagePropertyWrap *a1 = ObjectWrap::Unwrap<VtkImagePropertyWrap>(info[1]->ToObject());
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->AddLOD(
					(vtkImageMapper3D *) a0->native.GetPointer(),
					(vtkImageProperty *) a1->native.GetPointer(),
					info[2]->NumberValue()
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
		}
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkAbstractVolumeMapperWrap::ptpl))->HasInstance(info[0]))
	{
		VtkAbstractVolumeMapperWrap *a0 = ObjectWrap::Unwrap<VtkAbstractVolumeMapperWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkVolumePropertyWrap::ptpl))->HasInstance(info[1]))
		{
			VtkVolumePropertyWrap *a1 = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info[1]->ToObject());
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->AddLOD(
					(vtkAbstractVolumeMapper *) a0->native.GetPointer(),
					(vtkVolumeProperty *) a1->native.GetPointer(),
					info[2]->NumberValue()
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
		}
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkMapperWrap::ptpl))->HasInstance(info[0]))
	{
		VtkMapperWrap *a0 = ObjectWrap::Unwrap<VtkMapperWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkTextureWrap::ptpl))->HasInstance(info[1]))
		{
			VtkTextureWrap *a1 = ObjectWrap::Unwrap<VtkTextureWrap>(info[1]->ToObject());
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->AddLOD(
					(vtkMapper *) a0->native.GetPointer(),
					(vtkTexture *) a1->native.GetPointer(),
					info[2]->NumberValue()
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
		}
		else if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkPropertyWrap::ptpl))->HasInstance(info[1]))
		{
			VtkPropertyWrap *a1 = ObjectWrap::Unwrap<VtkPropertyWrap>(info[1]->ToObject());
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->AddLOD(
					(vtkMapper *) a0->native.GetPointer(),
					(vtkProperty *) a1->native.GetPointer(),
					info[2]->NumberValue()
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
		}
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkImageMapper3DWrap::ptpl))->HasInstance(info[0]))
	{
		VtkImageMapper3DWrap *a0 = ObjectWrap::Unwrap<VtkImageMapper3DWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->AddLOD(
				(vtkImageMapper3D *) a0->native.GetPointer(),
				info[1]->NumberValue()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkAbstractVolumeMapperWrap::ptpl))->HasInstance(info[0]))
	{
		VtkAbstractVolumeMapperWrap *a0 = ObjectWrap::Unwrap<VtkAbstractVolumeMapperWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->AddLOD(
				(vtkAbstractVolumeMapper *) a0->native.GetPointer(),
				info[1]->NumberValue()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkMapperWrap::ptpl))->HasInstance(info[0]))
	{
		VtkMapperWrap *a0 = ObjectWrap::Unwrap<VtkMapperWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->AddLOD(
				(vtkMapper *) a0->native.GetPointer(),
				info[1]->NumberValue()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkLODProp3DWrap::SetLODMapper(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLODProp3DWrap *wrapper = ObjectWrap::Unwrap<VtkLODProp3DWrap>(info.Holder());
	vtkLODProp3D *native = (vtkLODProp3D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkImageMapper3DWrap::ptpl))->HasInstance(info[1]))
		{
			VtkImageMapper3DWrap *a1 = ObjectWrap::Unwrap<VtkImageMapper3DWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetLODMapper(
				info[0]->Int32Value(),
				(vtkImageMapper3D *) a1->native.GetPointer()
			);
			return;
		}
		else if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkAbstractVolumeMapperWrap::ptpl))->HasInstance(info[1]))
		{
			VtkAbstractVolumeMapperWrap *a1 = ObjectWrap::Unwrap<VtkAbstractVolumeMapperWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetLODMapper(
				info[0]->Int32Value(),
				(vtkAbstractVolumeMapper *) a1->native.GetPointer()
			);
			return;
		}
		else if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkMapperWrap::ptpl))->HasInstance(info[1]))
		{
			VtkMapperWrap *a1 = ObjectWrap::Unwrap<VtkMapperWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetLODMapper(
				info[0]->Int32Value(),
				(vtkMapper *) a1->native.GetPointer()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLODProp3DWrap::SetLODProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLODProp3DWrap *wrapper = ObjectWrap::Unwrap<VtkLODProp3DWrap>(info.Holder());
	vtkLODProp3D *native = (vtkLODProp3D *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkImagePropertyWrap::ptpl))->HasInstance(info[1]))
		{
			VtkImagePropertyWrap *a1 = ObjectWrap::Unwrap<VtkImagePropertyWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetLODProperty(
				info[0]->Int32Value(),
				(vtkImageProperty *) a1->native.GetPointer()
			);
			return;
		}
		else if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkVolumePropertyWrap::ptpl))->HasInstance(info[1]))
		{
			VtkVolumePropertyWrap *a1 = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetLODProperty(
				info[0]->Int32Value(),
				(vtkVolumeProperty *) a1->native.GetPointer()
			);
			return;
		}
		else if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkPropertyWrap::ptpl))->HasInstance(info[1]))
		{
			VtkPropertyWrap *a1 = ObjectWrap::Unwrap<VtkPropertyWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetLODProperty(
				info[0]->Int32Value(),
				(vtkProperty *) a1->native.GetPointer()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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


text:
ALTER TABLE {$NAMESPACE}_phriction.phriction_content
  ADD phid VARBINARY(64) NOT NULL;

redpajama_set_name: RedPajamaGithub


text:
package org.assertj.core.internal.short2darrays;

import static org.mockito.Mockito.verify;

import org.assertj.core.api.AssertionInfo;
import org.assertj.core.internal.Short2DArrays;
import org.assertj.core.internal.Short2DArraysBaseTest;
import org.junit.jupiter.api.Test;

/**
 * Tests for <code>{@link Short2DArrays#assertHasDimensions(AssertionInfo, short[][], int, int)}</code>.
 *
 * @author Maciej Wajcht
 */
class Short2DArrays_assertHasDimensions_Test extends Short2DArraysBaseTest {

  @Test
  void should_delegate_to_Arrays2D() {
    // WHEN
    short2DArrays.assertHasDimensions(info, actual, 2, 3);
    // THEN
    verify(arrays2d).assertHasDimensions(info, failures, actual, 2, 3);
  }
}


text:
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _pure = require('recompose/pure');

var _pure2 = _interopRequireDefault(_pure);

var _SvgIcon = require('../../SvgIcon');

var _SvgIcon2 = _interopRequireDefault(_SvgIcon);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var ImageBrightness1 = function ImageBrightness1(props) {
  return _react2.default.createElement(
    _SvgIcon2.default,
    props,
    _react2.default.createElement('circle', { cx: '12', cy: '12', r: '10' })
  );
};
ImageBrightness1 = (0, _pure2.default)(ImageBrightness1);
ImageBrightness1.displayName = 'ImageBrightness1';

exports.default = ImageBrightness1;


text:
using System;
using System.Linq;
using Should;
using Xunit;

namespace Cassette
{
    public class HtmlAttributeDictionary_CombinedAttributes_Tests
    {
        [Fact]
        public void WhenEmptyDictionary_ThenEmptyString()
        {
            new HtmlAttributeDictionary().CombinedAttributes.ShouldBeEmpty();
        }

        [Fact]
        public void WhenAttributes_ThenContainsValidString()
        {
            var dictionary = new HtmlAttributeDictionary().Add(new { @class = "test", foo = "\"bar\"" } );
            dictionary.Add("async");

            dictionary.CombinedAttributes.ShouldEqual(" class=\"test\" foo=\""bar"\" async");
        }

    }

    public class HtmlAttributeDictionary_Add_Tests
    {
        [Fact]
        public void WithEmptyObject_ThenEmptyDictionary()
        {
            new HtmlAttributeDictionary().Add(new {}).ShouldBeEmpty();
        }

        [Fact]
        public void WithNullObject_ThenEmptyDictionary()
        {
            new HtmlAttributeDictionary().Add((object)null).ShouldBeEmpty();
        }

        [Fact]
        public void WithNameOnly_ThenNullValue()
        {
            new HtmlAttributeDictionary().Add("async")["async"].ShouldBeNull();
        }

        [Fact]
        public void WithObjectWithTwoProperties_ThenDictionaryTwoKeyValuePairs()
        {
            var target = new HtmlAttributeDictionary().Add(new { @class = "TestClass", async = "async" });

            target.Count.ShouldEqual(2);
            target["class"].ShouldEqual("TestClass");
            target["async"].ShouldEqual("async");
        }

        [Fact]
        public void WithDictionaryWithOneEntityAndObjectWithTwoProperties_ThenThreeKeyValuePairs()
        {
            var target = new HtmlAttributeDictionary();
            target.Add("existing", "value");

            target.Add(new { @class = "TestClass", async = "async" });

            target.Count.ShouldEqual(3);
        }

        [Fact]
        public void WithUpperPropertyName_ThenLowerName()
        {
            var target = new HtmlAttributeDictionary();

            target.Add(new { ASYNC = "async" });

            target.Where(k => k.Key == "async").Select(k => k.Key).FirstOrDefault().ShouldEqual("async");
        }

        [Fact]
        public void AddObject_WithUnderscorePropertyName_ThenDashPropertyName()
        {
            var target = new HtmlAttributeDictionary();

            target.Add(new { data_value = "test" });

            target.Where(k => k.Key == "data-value").Select(k => k.Key).FirstOrDefault().ShouldEqual("data-value");
        }

        [Fact]
        public void AddNameValuePair_WithUnderscorePropertyName_ThenRemainsUnderscoreName()
        {
            var target = new HtmlAttributeDictionary();

            target.Add("data_value", "test");

            target.Where(k => k.Key == "data_value").Select(k => k.Key).FirstOrDefault().ShouldEqual("data_value");
        }

        [Fact]
        public void WithBadValue_ThenValueSanitized()
        {
            new HtmlAttributeDictionary().Add("async", "a\"sync")["async"].ShouldEqual("a"sync");
        }

        [Fact]
        public void WithNullName_ThenArgumentException()
        {
            var target = new HtmlAttributeDictionary();

            Assert.Throws<ArgumentException>(
                () => target.Add(null, "async")
            );
        }

        [Fact]
        public void WithEmptyName_ThenArgumentException()
        {
            var target = new HtmlAttributeDictionary();

            Assert.Throws<ArgumentException>(
                () => target.Add(string.Empty, "async")
            );
        }

    }

    public class HtmlAttributeDictionary_ContainsAttribute_Tests
    {
        [Fact]
        public void GivenEmptyDictionary_ThenContainsAttributeIsFalse()
        {
            var target = new HtmlAttributeDictionary();
            target.ContainsAttribute("example").ShouldBeFalse();
        }

        [Fact]
        public void GivenAttributeInDictionary_ThenContainsAttributeIsTrue()
        {
            var target = new HtmlAttributeDictionary { "example" };
            target.ContainsAttribute("example").ShouldBeTrue();
        }

        [Fact]
        public void WhenAttributeNameIsNull_ThenContainsAttributesThrowsException()
        {
            var target = new HtmlAttributeDictionary();
            Assert.Throws<ArgumentException>(
                () => target.ContainsAttribute(null)
            );
        }

        [Fact]
        public void WhenAttributeNameIsEmpty_ThenContainsAttributesThrowsException()
        {
            var target = new HtmlAttributeDictionary();
            Assert.Throws<ArgumentException>(
                () => target.ContainsAttribute("")
            );
        }
    }

    public class HtmlAttributesDictionary_Remove_Tests
    {
        [Fact]
        public void GivenDictionaryWithAttribute_WhenRemoveAttributeByName_ThenReturnTrue()
        {
            var target = new HtmlAttributeDictionary { "test" };
            var removed = target.Remove("test");
            removed.ShouldBeTrue();
        }

        [Fact]
        public void GivenDictionaryWithAttribute_WhenRemoveAttributeWithDifferentName_ThenReturnFalse()
        {
            var target = new HtmlAttributeDictionary { "test" };
            var removed = target.Remove("something-else");
            removed.ShouldBeFalse();
        }

        [Fact]
        public void WhenRemoveAttributeWithNullName_ThenThrowException()
        {
            var target = new HtmlAttributeDictionary();
            Assert.Throws<ArgumentException>(
                () => target.Remove(null)
            );
        }

        [Fact]
        public void WhenRemoveAttributeWithEmptyName_ThenThrowException()
        {
            var target = new HtmlAttributeDictionary();
            Assert.Throws<ArgumentException>(
                () => target.Remove("")
            );
        }
    }

    public class HtmlAttributeDictionary_Indexer_Tests
    {
        [Fact]
        public void CanSetAndGetValueByName()
        {
            var target = new HtmlAttributeDictionary();

            target["test"] = "value";

            target["test"].ShouldEqual("value");
        }

        [Fact]
        public void WhenSetAttributeWithNullName_ThenThrowException()
        {
            var target = new HtmlAttributeDictionary();
            Assert.Throws<ArgumentException>(
                () => target[null] = "value"
            );
        }

        [Fact]
        public void WhenGetAttributeWithNullName_ThenThrowException()
        {
            var target = new HtmlAttributeDictionary();
            Assert.Throws<ArgumentException>(
                () => { var _ = target[null]; }
            );
        }
    }
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <title>Using PhyloPen • Arbor</title>
    <meta name="description" content="Evaluating PhyloPen

">
    <meta name="keywords" content="">

	<meta name="twitter:title" content="Using PhyloPen">
	<meta name="twitter:description" content="Evaluating PhyloPen

">
	<meta name="twitter:site" content="@lukejharmon">

	<meta name="twitter:card" content="summary">
	<meta name="twitter:image" content="/images/120x120.gif">

	<meta property="og:locale" content="en_US">
	<meta property="og:type" content="article">
	<meta property="og:title" content="Using PhyloPen">
	<meta property="og:description" content="Evaluating PhyloPen

">
	<meta property="og:url" content="/tutorials/Using-PhyloPen/">
	<meta property="og:site_name" content="Arbor">

    <link rel="canonical" href="/tutorials/Using-PhyloPen/">

    <link href="/atom.xml" type="application/atom+xml" rel="alternate" title="Arbor Atom Feed">
    <link href="/sitemap.xml" type="application/xml" rel="sitemap" title="Sitemap">

    <meta name="HandheldFriendly" content="True">
    <meta name="MobileOptimized" content="320">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="cleartype" content="on">

    <link rel="stylesheet" href="/css/main.css">

    Arbor

Arbor

Help

Use Arbor

Docs & tutorials

Developers

Contact

Arbor Table of Contents

Help

Get help

Use Arbor

Run Arbor over the web or install it yourself

Docs & tutorials

Full documentation for functions and workflows

Developers

Add to the Arbor code base

Contact

Contact us

<button type="button" id="js-menu-trigger" class="sliding-menu-button lines-button x2" role="button" aria-label="Toggle Navigation">

</button>

        Home
       ›

        Tutorials

Using PhyloPen

Evaluating PhyloPen

Please try the following exercise to evaluate the current version of our new application PhyloPen. PhyloPen is an interface that lets you interact with a phylogenetic tree and a matching trait matrix to explore features about organisms and their relationships to each other.

If you have any difficulties during the exercises, please feel free to ask for assistance. Also, remember
to consult the tables that show what gestures can be performed in PhyloPen (i.e., pen and multitouch gestures.)

Before starting, please complete this pre-activity survey.

The instructions for PhyloPen are here. Download and save this file somewhere to your computer. Follow these instructions to test the various capabilities of PhyloPen using the supplied tablet.

Next, attempt to complete the same tasks in Mesquite using these instructions.

When you have completed the exercises, please provide feedback using this post-activity survey

Written by Curt Lisle

CEO of KnowledgeVis

	 Share on Twitter
	 Share on Facebook
	 Share on Google+

Updated <time datetime="2018-09-21T00:00:00Z" itemprop="datePublished">September 21, 2018</time>

Please enable JavaScript to view the comments powered by Disqus.

Home

Getting Started

About

Team

© 2018 Arbor powered by Jekyll + Skinny Bones.


text:
#include <string>
#include <thread>
#define EXOENV_CPP
#include <exodus/exoenv.h>

// avoid this unless absolutely necessary then possible to move this file out of exodus var library
//(stick to throwing VarError with a suitable error message)

namespace exodus {

//int getprocessno(const char* filename, int* fd);
//bool processno_islocked2(int processno, int* fd);

//void releaseprocess(int* fd);
std::string mvgethostname();

// NB do not define default copy constructor and assignment in order to force
// derived classes to implement them since they are defined in the class header

// destructor
ExoEnv::~ExoEnv() {

	// std::wcout<<"ExoEnv: Closing Definitions ... "<<std::flush;
	if (this->DEFINITIONS.assigned() && this->DEFINITIONS) {
		this->DEFINITIONS.close();
	}
	// std::wcout<<"OK"<<std::endl;

	// std::wcout<<"ExoEnv: Disconnecting DB ... "<<std::flush;
	if (this->SESSION.assigned() && this->SESSION) {
		this->SESSION.close();
	}
	// std::wcout<<"OK"<<std::endl;

	// a file handle to make unique locks
	//if (processnolockfd != 0)
	//	releaseprocess(&processnolockfd);
}

// keep in sync both 1) declaration in class and 2) contruction initialisation
bool ExoEnv::init(const int threadno) {

	// std::wcout<<"ExoEnv::init("<<threadno<<")"<<std::endl;

	this->THREADNO = threadno;

	// pretty obsolete nowadays
	// environment variables may not be available until exported
	// do set -p to find out exported variables instead of all
	if (not this->CRTWIDE.osgetenv("COLUMNS") or not this->CRTWIDE)
		this->CRTWIDE = 80;
	if (not this->CRTHIGH.osgetenv("LINES") or not this->CRTHIGH)
		this->CRTHIGH = 25;

	//	this->THREADNO.outputl("PROCESS NO ===================================================== ");

	//this->STATION = var(mvgethostname()).field(".", 1);

	return true;
}

//bool ExoEnv::processno_islocked(int processno)
//{
//	return processno_islocked2(processno, &processnolockfd);
//}

}  // namespace exodus


text:
<?PHP
/* ====================
[BEGIN_SED_EXTPLUGIN]
Code=passrecover
Part=main
File=passrecover
Hooks=standalone
Tags=
Order=10
[END_SED_EXTPLUGIN]
==================== */

/**
 * Sends emails to users so they can recovery their passwords
 *
 * @package Cotonti
 * @version 0.0.3
 * @author Neocrome, Cotonti Team
 * @copyright Copyright (c) Cotonti Team 2008-2009
 * @license BSD
 */

defined('SED_CODE') && defined('SED_PLUG') or die('Wrong URL');

$a = sed_import('a','G','TXT');
$v = sed_import('v','G','TXT');
$email = sed_import('email','P','TXT');

$plugin_title = $L['plu_title'];
$t->assign(array('PASSRECOVER_TITLE'=> $plugin_title));

/**
*Random password generator for password recovery plugin
*@return string and numbers ($pass)
*/

function sed_randompass()
{
	$abc = "abcdefghijklmnoprstuvyz";
	$vars = $abc.strtoupper($abc)."0123456789";
	srand((double)microtime()*1000000);
	$i = 0;
	while($i <= 7)
	{
		$num = rand() % 33;
		$tmp = substr($vars, $num, 1);
		$pass = $pass . $tmp;
		$i++;
	}
	return $pass;
}

if($a == 'request' && $email != '')
{
	sed_shield_protect();
	$sql = sed_sql_query("SELECT user_id, user_name, user_lostpass FROM $db_users WHERE user_email='".sed_sql_prep($email)."' ORDER BY user_id ASC LIMIT 1");

	if($row = sed_sql_fetcharray($sql))
	{
		$rusername = $row['user_name'];
		$ruserid = $row['user_id'];
		$validationkey = $row['user_lostpass'];

		if(empty($validationkey) || $validationkey == "0")
		{
			$validationkey = md5(microtime());
			$sql = sed_sql_query("UPDATE $db_users SET user_lostpass='$validationkey', user_lastip='".$usr['ip']."' WHERE user_id='$ruserid'");

		}

		sed_shield_update(60,"Password recovery email sent");

		$rinfo = sprintf($L['plu_email1b'], $usr['ip'], date("Y-m-d H:i"));

		$rsubject = $cfg['maintitle']." - ".$L['plu_title'];
		$ractivate = $cfg['mainurl'].'/'.sed_url('plug', 'e=passrecover&a=auth&v='.$validationkey, '', true);
		$rbody = $L['Hi']." ".$rusername.",\n\n".$L['plu_email1']."\n\n".$ractivate. "\n\n".$rinfo. "\n\n ".$L['aut_contactadmin'];
		sed_mail ($email, $rsubject, $rbody);
		$t->parse('MAIN.REQUEST');
	}
	else
	{
		sed_shield_update(10,"Password recovery requested");

		sed_log("Pass recovery failed, user : ".$rusername);
		header("Location: ".SED_ABSOLUTE_URL.sed_url('message', 'msg=151', '', true));
		exit;
	}
}
elseif($a == 'auth' && mb_strlen($v) == 32)
{
	sed_shield_protect();

	$sql = sed_sql_query("SELECT user_name, user_id, user_email, user_password, user_maingrp, user_banexpire FROM $db_users WHERE user_lostpass='".sed_sql_prep($v)."'");

	if($row = sed_sql_fetcharray($sql))
	{
		$rmdpass  = $row['user_password'];
		$rusername = $row['user_name'];
		$ruserid = $row['user_id'];
		$rusermail = $row['user_email'];

		if($row['user_maingrp'] == 2)
		{
			sed_log("Password recovery failed, user inactive : ".$rusername);
			header("Location: " . SED_ABSOLUTE_URL . sed_url('message', 'msg=152', '', true));
			exit;
		}

		if($row['user_maingrp'] == 3)
		{
			sed_log("Password recovery failed, user banned : ".$rusername);
			header("Location: " . SED_ABSOLUTE_URL . sed_url('message', 'msg=153&num='.$row['user_banexpire'], '', true));
			exit;
		}

		$validationkey = md5(microtime());
		$newpass = sed_randompass();
		$ruserpass = array();
		$ruserpass['user_passsalt'] = sed_unique(16);
		$ruserpass['user_passfunc'] = empty($cfg['hashfunc']) ? 'sha256' : $cfg['hashfunc'];
		$ruserpass['user_password'] = sed_hash($newpass, $ruserpass['user_passsalt'], $ruserpass['user_passfunc']);
		$ruserpass['user_lostpass'] = $validationkey;
		sed_sql_update($db_users, "user_id=$ruserid", $ruserpass);

		$rsubject = $cfg['maintitle']." - ".$L['plu_title'];
		$rbody = $L['Hi']." ".$rusername.",\n\n".$L['plu_email2']."\n\n".$newpass. "\n\n".$L['aut_contactadmin'];
		sed_mail($rusermail, $rsubject, $rbody);
		$t->parse('MAIN.AUTH');
	}
	else
	{
		sed_shield_update(7,"Log in");
		sed_log("Pass recovery failed, user : ".$rusername);
		header("Location: ".SED_ABSOLUTE_URL.sed_url('message', 'msg=151', '', true));
		exit;
	}
}
else
{
	$t->assign(array('PASSRECOVER_URL_FORM'=> sed_url('plug', 'e=passrecover&a=request')));
	$t->parse('MAIN.PASSRECOVER');
}

?>


text:
<?php

defined('C5_EXECUTE') or die("Access Denied.");

use Concrete\Core\Block\Block;
use Concrete\Core\Form\Service\Form;
use Concrete\Core\Permission\Key\Key;
use Concrete\Core\Permission\Duration;
use Concrete\Core\Support\Facade\Application;
use Concrete\Core\User\Group\Group;
use Concrete\Core\Validation\CSRF\Token;
use Concrete\Core\View\View;
use Concrete\Core\Permission\Category;

/** @var Block $b */
/** @var int $rcID */

$app = Application::getFacadeApplication();
/** @var Form $form */
$form = $app->make(Form::class);
/** @var Token $token */
$token = $app->make(Token::class);

$c = $b->getBlockCollectionObject();
$arHandle = $b->getAreaHandle();

$pk = Key::getByHandle('view_block');
$pk->setPermissionObject($b);
$list = $pk->getAccessListItems();

foreach ($list as $pa) {
    $pae = $pa->getAccessEntityObject();

    if ($pae->getAccessEntityTypeHandle() == 'group') {
        /** @noinspection PhpPossiblePolymorphicInvocationInspection */
        $groupObject = $pae->getGroupObject();

        if ($groupObject instanceof Group) {
            if ($groupObject->getGroupID() == GUEST_GROUP_ID) {
                $pd = $pa->getPermissionDurationObject();

                if (!is_object($pd)) {
                    $pd = new Duration();
                }
            }
        }
    }
}
?>

    <form id="ccm-permissions-timed-guest-access-form" class="form-stacked" method="post"
          action="<?= h(Category::getByHandle('block')->getTaskURL()) ?>">

        <?php echo $form->hidden('task', 'set_timed_guest_access'); ?>
        <?php echo $form->hidden('cID', $c->getCollectionID()); ?>
        <?php echo $form->hidden('bID', $b->getBlockID()); ?>
        <?php echo $form->hidden('arHandle', $arHandle); ?>

            <?php echo t('When should guests be able to view this block?') ?>

        <?php /** @noinspection PhpUnhandledExceptionInspection */
        echo View::element('permission/duration', ['pd' => $pd]); ?>

            <input type="button" onclick="jQuery.fn.dialog.closeTop()" value="<?php echo h(t('Cancel')) ?>"
                   class="btn btn-secondary float-start"/>

            <input type="submit" onclick="$('#ccm-permissions-timed-guest-access-form').submit()"
                   value="<?php echo h(t('Save')) ?>" class="btn btn-primary float-end"/>

    </form>


text:
BRYSerialAnimationQueue
=======================

Perform UIView animations serially without blocking the main thread, using the same APIs you already know and love.

The main goal of the class is to make it easy to perform event-based animations (e.g. a user taps a button or a network callback completes). One perfect example is displaying banners inside of an application when push notifications are received. Simply add animation blocks to a `BRYSerialAnimationQueueInstance` and they'll be executed only once all of the previously queued animations have completed.

An added benefit is that nested animation code like this:

    [UIView animateWithDuration:duration animations:^{
        label.alpha = 1;

    } completion:^(BOOL finished) {
        [UIView animateWithDuration:duration delay:delay animations:^{
            label.alpha = 0;

        } completion:^(BOOL finished) {
            [label removeFromSuperview];
        }];
    }];

Can be replaced with something a little cleaner, like:

    [queue animateWithDuration:duration animations:^{
        label.alpha = 1;
    }];

    [queue animateWithDuration:duration delay:delay animations:^{
        label.alpha = 0;

    } completion:^(BOOL finished) {
        [label removeFromSuperview];
    }];


text:
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

// ToDo:
// Static public Poder crear ladrillos individuales
// Arreglar (o Balancear) PropagateImpact Nota: Arreglar Distancia
// Agregar columnas fijas al suelo?

public class BigWall : MonoBehaviour, IWall
{
    Vector3 area;
    static Vector3 _brickSize;
    float expansionOnda; //Factor de propagación de la onda de impacto
    public PhysicMaterial materialFisico;
    Dictionary<Vector3, GameObject> bricks;

    static public Vector3 brickSize
    {
        get
        {
            return _brickSize;
        }
        private set
        {
            _brickSize = value;
        }

    }
    void Awake()
    {
        _brickSize = new Vector3(1.5f, 0.375f, 0.75f); //x = 2*z = 4*y
        area = new Vector3(4, 8, 1); //In Bricks size. //Unidad ocupa 6*3*0.75(precario)
        expansionOnda = 4; //Cuanto más chico, más expansion
        bricks = new Dictionary<Vector3, GameObject>();

    }
    // Use this for initialization
    void Start()
    {

    }

    // Update is called once per frame
    void Update()
    {

    }
    /// <summary>
    /// Crea la pared que se va a representar en el juego
    /// </summary>
    /// <param name="doble">Doble longitud?</param>
    ///
    public void CrearColumna()
    {
        GameObject Cube;
        Material Madera = Resources.Load("Materials/Wood", typeof(Material)) as Material;
        FixedJoint fixedJointBase;

        for (int i = 0; i < area.y; i++)
        {
              Cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
              Cube.transform.localScale = _brickSize + new Vector3(-_brickSize.z,0,0);
              Cube.transform.position = new Vector3(0, _brickSize.y / 2 + i * _brickSize.y, 0);
              Cube.transform.parent = transform;
              Cube.transform.rotation = transform.rotation;
              Cube.GetComponent<BoxCollider>().material = materialFisico;
              Cube.GetComponent<MeshRenderer>().material = Madera;
              Cube.AddComponent<Rigidbody>().mass = 100 * _brickSize.x * _brickSize.y * _brickSize.z;
              bricks.Add(new Vector3(0, i, 0), Cube);
              if (i > 0)
              {
                  fixedJointBase = bricks[new Vector3(0, i, 0)].AddComponent<FixedJoint>();
                  fixedJointBase.connectedBody = bricks[new Vector3(0, i - 1, 0)].GetComponent<Rigidbody>();
                  fixedJointBase.breakForce = 800; //Esto en 10000 crea filas

              }
        }

    }

    public void CrearPared(bool doble)
    {
        //Variables temporales
        GameObject Cube;
        Vector3 posicion;
        Material Madera = Resources.Load("Materials/Wood", typeof(Material)) as Material;
        FixedJoint fixedJointBase;

        //Definición de variables de la clase globales

        for (float i = 0; i < area.x; i++) // X = Ancho
        {
            for (float j = 0; j < area.y; j++) // Y = Altura
            {
                for (float k = 0; k < area.z; k++) // Z = Profundo
                {
                    Cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
                    Cube.transform.localScale = _brickSize;
                    Cube.transform.parent = transform;
                    posicion = new Vector3(-area.x * _brickSize.x / 2 + _brickSize.x * 3/ 4 + i * _brickSize.x, _brickSize.y / 2 + j * _brickSize.y,
                                            -area.z * _brickSize.z / 2 + _brickSize.z / 2 + k * _brickSize.z);
                    Cube.transform.localPosition = posicion;

                    if ((j % 2) == 0)
                    {
                        Cube.transform.localPosition += new Vector3(-_brickSize.z, 0, 0);
                        if (i == 0)
                        {
                            Cube.transform.localScale  += new Vector3(-_brickSize.z, 0, 0);
                            Cube.transform.localPosition += new Vector3(_brickSize.y, 0, 0);
                        }

                    }

                    else if (i == (area.x - 1))
                    {
                        Cube.transform.localScale += new Vector3(-_brickSize.z, 0, 0);
                        Cube.transform.localPosition += new Vector3(-_brickSize.y, 0, 0);
                    }

                    Cube.transform.rotation = transform.rotation;
                    Cube.GetComponent<BoxCollider>().material = materialFisico;
                    Cube.GetComponent<MeshRenderer>().material = Madera;
                    Cube.AddComponent<Rigidbody>().mass = 100 * _brickSize.x * _brickSize.y * _brickSize.z;
                    bricks.Add(new Vector3(i, j, k), Cube);
                    if (i > 0)
                    {
                        fixedJointBase = bricks[new Vector3(i, j, k)].AddComponent<FixedJoint>();
                        fixedJointBase.connectedBody = bricks[new Vector3(i - 1, j, k)].GetComponent<Rigidbody>();
                        fixedJointBase.breakForce = 800; //Esto en 10000 crea filas

                    }
                    if (j > 0)
                    {
                        fixedJointBase = bricks[new Vector3(i, j, k)].AddComponent<FixedJoint>();
                        fixedJointBase.connectedBody = bricks[new Vector3(i, j - 1, k)].GetComponent<Rigidbody>();
                        fixedJointBase.breakForce = 1000; //Esto en 10000 crea columnas
                    }
                    if (k > 0)
                    {

                        fixedJointBase = bricks[new Vector3(i, j, k)].AddComponent<FixedJoint>();
                        fixedJointBase.connectedBody = bricks[new Vector3(i, j, k - 1)].GetComponent<Rigidbody>();
                        fixedJointBase.breakForce = 150;
                    }
                    Cube.AddComponent<Brick>().Init(new Vector3(i, j, k), this);

                }
            }
        } //Bricks generation

    }

    public GameObject[] UltimosLadrillos()
    {
        GameObject[] lista = new GameObject[(int)(area.y*area.z)];
        for (int k = 0; k < area.z; k++) // Z = Profundo
        {
            for (int j = 0; j < area.y; j++) // Y = Altura
            {
                lista[j] = bricks[new Vector3(area.x-1, j, k)];
            }
        }
        return lista;
    }
    public GameObject[] PrimerosLadrillos()
    {
        GameObject[] lista = new GameObject[(int)(area.y * area.z)];
        for (int k = 0; k < area.z; k++) // Z = Profundo
        {
            for (int j = 0; j < area.y; j++) // Y = Altura
            {
                lista[j] = bricks[new Vector3(0, j, k)];
            }
        }
        return lista;
    }

    public void CheckCollision(Vector3 posicion, Vector3 impulso)
    {
        if (impulso.magnitude > 100)
        {
            PropagateImpact(posicion, impulso/expansionOnda);
        }
    }
     private void PropagateImpact(GameObject ladrillo, Vector3 fuerza)
     {
         Vector3 posicion = ladrillo.GetComponent<Brick>().pos;

         _PropagateImpact(posicion, fuerza);

     }
     private void PropagateImpact(Vector3 posicion, Vector3 fuerza)
     {

         _PropagateImpact(posicion, fuerza);

     }

    private void _PropagateImpact(Vector3 posicion, Vector3 fuerza)
    {

         if (fuerza.magnitude > 100)
         {
             GameObject ladrilloContinuo;

             if (posicion.x < area.x - 1)
             {
                 ladrilloContinuo = bricks[posicion + new Vector3(1, 0, 0)];
                 if (Vector3.Distance(ladrilloContinuo.transform.position,transform.position) < brickSize.x)
                 {
                     ladrilloContinuo.GetComponent<Rigidbody>().AddForce(fuerza,ForceMode.Force);
                     PropagateImpact(ladrilloContinuo, fuerza / expansionOnda / _brickSize.x);
                 }
             }
             if(posicion.x > 0)
             {
                 ladrilloContinuo = bricks[posicion + new Vector3(-1, 0, 0)];
                 if (Vector3.Distance(ladrilloContinuo.transform.position, transform.position) < brickSize.x)
                 {
                     ladrilloContinuo.GetComponent<Rigidbody>().AddForce(fuerza, ForceMode.Impulse);
                     PropagateImpact(ladrilloContinuo, fuerza / expansionOnda / _brickSize.x);
                 }
             }

             if (posicion.y < area.y - 1)
             {
                 ladrilloContinuo = bricks[posicion + new Vector3(0, 1, 0)];
                 if (Vector3.Distance(ladrilloContinuo.transform.position, transform.position) < brickSize.y + 0.25f)
                 {
                     ladrilloContinuo.GetComponent<Rigidbody>().AddForce(fuerza, ForceMode.Impulse);
                     PropagateImpact(ladrilloContinuo, fuerza / expansionOnda / _brickSize.y);
                 }
             }
             if (posicion.y > 0)
             {
                 ladrilloContinuo = bricks[posicion + new Vector3(0, -1, 0)];
                 if (Vector3.Distance(ladrilloContinuo.transform.position, transform.position) < brickSize.y + 0.25f)
                 {
                     ladrilloContinuo.GetComponent<Rigidbody>().AddForce(fuerza, ForceMode.Impulse);
                     PropagateImpact(ladrilloContinuo, fuerza / expansionOnda / _brickSize.y);
                 }
             }

             if (posicion.z < area.z - 1)
             {
                 ladrilloContinuo = bricks[posicion + new Vector3(0, 0, 1)];
                 if (Vector3.Distance(ladrilloContinuo.transform.position, transform.position) < brickSize.z + 0.25f)
                 {
                     ladrilloContinuo.GetComponent<Rigidbody>().AddForce(fuerza, ForceMode.Impulse);
                     PropagateImpact(ladrilloContinuo, fuerza / expansionOnda / _brickSize.z);
                 }
             }
             if (posicion.z > 0)
             {
                 ladrilloContinuo = bricks[posicion + new Vector3(0, 0, -1)];
                 if (Vector3.Distance(ladrilloContinuo.transform.position, transform.position) < brickSize.z + 0.25f)
                 {
                     ladrilloContinuo.GetComponent<Rigidbody>().AddForce(fuerza, ForceMode.Impulse);
                     PropagateImpact(ladrilloContinuo, fuerza / expansionOnda / _brickSize.z);
                 }
             }

         }
     }

    void OnDrawGizmos()
    {
    }

}


text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>mailto-link example 2: popup another page (your contact form)</title>
  <link rel="stylesheet" href="../bower_components/bootstrap/dist/css/bootstrap.min.css">
  <link rel="stylesheet" href="../bower_components/bootstrap/dist/css/bootstrap-theme.min.css">

        <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
          Toggle navigation

        </button>
        mailto-link

            Test drop

Blank

mailto

Redirect

Popup (current)

mailto-link example 2: popup

  This example shows how to transform your "mailto:" links so that they open up a popup with a contact form.

Demo

Click to mail test@example.com

Click to mail fail@example.com (failing)

Click to mail silent@example.com (no feedback)


text:
#pragma once

/**
 * Hitachi HD44780 display defines and headers
 */

#include "../../inc/MarlinConfig.h"

#if ENABLED(LCD_I2C_TYPE_PCF8575)

  // NOTE: These are register-mapped pins on the PCF8575 controller, not Arduino pins.
  #define LCD_I2C_PIN_BL  3
  #define LCD_I2C_PIN_EN  2
  #define LCD_I2C_PIN_RW  1
  #define LCD_I2C_PIN_RS  0
  #define LCD_I2C_PIN_D4  4
  #define LCD_I2C_PIN_D5  5
  #define LCD_I2C_PIN_D6  6
  #define LCD_I2C_PIN_D7  7

  #include <Wire.h>
  #include <LCD.h>
  #include <LiquidCrystal_I2C.h>
  #define LCD_CLASS LiquidCrystal_I2C

#elif ENABLED(LCD_I2C_TYPE_MCP23017)

  // For the LED indicators (which may be mapped to different events in update_indicators())
  #define LCD_HAS_STATUS_INDICATORS
  #define LED_A 0x04 //100
  #define LED_B 0x02 //010
  #define LED_C 0x01 //001

  #include <Wire.h>
  #include <LiquidTWI2.h>
  #define LCD_CLASS LiquidTWI2

#elif ENABLED(LCD_I2C_TYPE_MCP23008)

  #include <Wire.h>
  #include <LiquidTWI2.h>
  #define LCD_CLASS LiquidTWI2

#elif ENABLED(LCD_I2C_TYPE_PCA8574)

  #include <LiquidCrystal_I2C.h>
  #define LCD_CLASS LiquidCrystal_I2C

#elif ENABLED(SR_LCD_2W_NL)

  // 2 wire Non-latching LCD SR from:
  // https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/schematics#!shiftregister-connection
  #include <LCD.h>
  #include <LiquidCrystal_SR.h>
  #define LCD_CLASS LiquidCrystal_SR

#elif ENABLED(SR_LCD_3W_NL)

  // NewLiquidCrystal didn't work, so this uses
  // https://github.com/mikeshub/SailfishLCD

  #include <SailfishLCD.h>
  #define LCD_CLASS LiquidCrystalSerial

#elif ENABLED(LCM1602)

  #include <Wire.h>
  #include <LCD.h>
  #include <LiquidCrystal_I2C.h>
  #define LCD_CLASS LiquidCrystal_I2C

#elif ENABLED(YHCB2004)

  #include <LiquidCrystal_AIP31068_SPI.h>
  #define LCD_CLASS LiquidCrystal_AIP31068_SPI

#else

  // Standard directly connected LCD implementations
  #include <LiquidCrystal.h>
  #define LCD_CLASS LiquidCrystal

#endif

#include "../fontutils.h"
#include "../lcdprint.h"