using CPF.Mac.CoreGraphics;
using CPF.Mac.CoreImage;
using CPF.Mac.Foundation;
using CPF.Mac.ObjCRuntime;
using System;
using System.ComponentModel;

namespace CPF.Mac.CoreAnimation
{
	[Register("CALayer", true)]
	public class CALayer : NSObject
	{
		private const string selInitWithLayer = "initWithLayer:";

		private static readonly IntPtr selPresentationLayerHandle = Selector.GetHandle("presentationLayer");

		private static readonly IntPtr selModelLayerHandle = Selector.GetHandle("modelLayer");

		private static readonly IntPtr selBoundsHandle = Selector.GetHandle("bounds");

		private static readonly IntPtr selSetBounds_Handle = Selector.GetHandle("setBounds:");

		private static readonly IntPtr selZPositionHandle = Selector.GetHandle("zPosition");

		private static readonly IntPtr selSetZPosition_Handle = Selector.GetHandle("setZPosition:");

		private static readonly IntPtr selAnchorPointHandle = Selector.GetHandle("anchorPoint");

		private static readonly IntPtr selSetAnchorPoint_Handle = Selector.GetHandle("setAnchorPoint:");

		private static readonly IntPtr selAnchorPointZHandle = Selector.GetHandle("anchorPointZ");

		private static readonly IntPtr selSetAnchorPointZ_Handle = Selector.GetHandle("setAnchorPointZ:");

		private static readonly IntPtr selPositionHandle = Selector.GetHandle("position");

		private static readonly IntPtr selSetPosition_Handle = Selector.GetHandle("setPosition:");

		private static readonly IntPtr selTransformHandle = Selector.GetHandle("transform");

		private static readonly IntPtr selSetTransform_Handle = Selector.GetHandle("setTransform:");

		private static readonly IntPtr selAffineTransformHandle = Selector.GetHandle("affineTransform");

		private static readonly IntPtr selSetAffineTransform_Handle = Selector.GetHandle("setAffineTransform:");

		private static readonly IntPtr selFrameHandle = Selector.GetHandle("frame");

		private static readonly IntPtr selSetFrame_Handle = Selector.GetHandle("setFrame:");

		private static readonly IntPtr selIsHiddenHandle = Selector.GetHandle("isHidden");

		private static readonly IntPtr selSetHidden_Handle = Selector.GetHandle("setHidden:");

		private static readonly IntPtr selIsDoubleSidedHandle = Selector.GetHandle("isDoubleSided");

		private static readonly IntPtr selSetDoubleSided_Handle = Selector.GetHandle("setDoubleSided:");

		private static readonly IntPtr selIsGeometryFlippedHandle = Selector.GetHandle("isGeometryFlipped");

		private static readonly IntPtr selSetGeometryFlipped_Handle = Selector.GetHandle("setGeometryFlipped:");

		private static readonly IntPtr selContentsAreFlippedHandle = Selector.GetHandle("contentsAreFlipped");

		private static readonly IntPtr selSuperlayerHandle = Selector.GetHandle("superlayer");

		private static readonly IntPtr selSublayersHandle = Selector.GetHandle("sublayers");

		private static readonly IntPtr selSetSublayers_Handle = Selector.GetHandle("setSublayers:");

		private static readonly IntPtr selSublayerTransformHandle = Selector.GetHandle("sublayerTransform");

		private static readonly IntPtr selSetSublayerTransform_Handle = Selector.GetHandle("setSublayerTransform:");

		private static readonly IntPtr selMaskHandle = Selector.GetHandle("mask");

		private static readonly IntPtr selSetMask_Handle = Selector.GetHandle("setMask:");

		private static readonly IntPtr selMasksToBoundsHandle = Selector.GetHandle("masksToBounds");

		private static readonly IntPtr selSetMasksToBounds_Handle = Selector.GetHandle("setMasksToBounds:");

		private static readonly IntPtr selContentsHandle = Selector.GetHandle("contents");

		private static readonly IntPtr selSetContents_Handle = Selector.GetHandle("setContents:");

		private static readonly IntPtr selLayoutManagerHandle = Selector.GetHandle("layoutManager");

		private static readonly IntPtr selSetLayoutManager_Handle = Selector.GetHandle("setLayoutManager:");

		private static readonly IntPtr selContentsScaleHandle = Selector.GetHandle("contentsScale");

		private static readonly IntPtr selSetContentsScale_Handle = Selector.GetHandle("setContentsScale:");

		private static readonly IntPtr selContentsRectHandle = Selector.GetHandle("contentsRect");

		private static readonly IntPtr selSetContentsRect_Handle = Selector.GetHandle("setContentsRect:");

		private static readonly IntPtr selContentsGravityHandle = Selector.GetHandle("contentsGravity");

		private static readonly IntPtr selSetContentsGravity_Handle = Selector.GetHandle("setContentsGravity:");

		private static readonly IntPtr selContentsCenterHandle = Selector.GetHandle("contentsCenter");

		private static readonly IntPtr selSetContentsCenter_Handle = Selector.GetHandle("setContentsCenter:");

		private static readonly IntPtr selMinificationFilterHandle = Selector.GetHandle("minificationFilter");

		private static readonly IntPtr selSetMinificationFilter_Handle = Selector.GetHandle("setMinificationFilter:");

		private static readonly IntPtr selMagnificationFilterHandle = Selector.GetHandle("magnificationFilter");

		private static readonly IntPtr selSetMagnificationFilter_Handle = Selector.GetHandle("setMagnificationFilter:");

		private static readonly IntPtr selIsOpaqueHandle = Selector.GetHandle("isOpaque");

		private static readonly IntPtr selSetOpaque_Handle = Selector.GetHandle("setOpaque:");

		private static readonly IntPtr selNeedsDisplayHandle = Selector.GetHandle("needsDisplay");

		private static readonly IntPtr selNeedsDisplayOnBoundsChangeHandle = Selector.GetHandle("needsDisplayOnBoundsChange");

		private static readonly IntPtr selSetNeedsDisplayOnBoundsChange_Handle = Selector.GetHandle("setNeedsDisplayOnBoundsChange:");

		private static readonly IntPtr selBackgroundColorHandle = Selector.GetHandle("backgroundColor");

		private static readonly IntPtr selSetBackgroundColor_Handle = Selector.GetHandle("setBackgroundColor:");

		private static readonly IntPtr selCornerRadiusHandle = Selector.GetHandle("cornerRadius");

		private static readonly IntPtr selSetCornerRadius_Handle = Selector.GetHandle("setCornerRadius:");

		private static readonly IntPtr selBorderWidthHandle = Selector.GetHandle("borderWidth");

		private static readonly IntPtr selSetBorderWidth_Handle = Selector.GetHandle("setBorderWidth:");

		private static readonly IntPtr selBorderColorHandle = Selector.GetHandle("borderColor");

		private static readonly IntPtr selSetBorderColor_Handle = Selector.GetHandle("setBorderColor:");

		private static readonly IntPtr selOpacityHandle = Selector.GetHandle("opacity");

		private static readonly IntPtr selSetOpacity_Handle = Selector.GetHandle("setOpacity:");

		private static readonly IntPtr selEdgeAntialiasingMaskHandle = Selector.GetHandle("edgeAntialiasingMask");

		private static readonly IntPtr selSetEdgeAntialiasingMask_Handle = Selector.GetHandle("setEdgeAntialiasingMask:");

		private static readonly IntPtr selActionsHandle = Selector.GetHandle("actions");

		private static readonly IntPtr selSetActions_Handle = Selector.GetHandle("setActions:");

		private static readonly IntPtr selAnimationKeysHandle = Selector.GetHandle("animationKeys");

		private static readonly IntPtr selNameHandle = Selector.GetHandle("name");

		private static readonly IntPtr selSetName_Handle = Selector.GetHandle("setName:");

		private static readonly IntPtr selDelegateHandle = Selector.GetHandle("delegate");

		private static readonly IntPtr selSetDelegate_Handle = Selector.GetHandle("setDelegate:");

		private static readonly IntPtr selBeginTimeHandle = Selector.GetHandle("beginTime");

		private static readonly IntPtr selSetBeginTime_Handle = Selector.GetHandle("setBeginTime:");

		private static readonly IntPtr selDurationHandle = Selector.GetHandle("duration");

		private static readonly IntPtr selSetDuration_Handle = Selector.GetHandle("setDuration:");

		private static readonly IntPtr selSpeedHandle = Selector.GetHandle("speed");

		private static readonly IntPtr selSetSpeed_Handle = Selector.GetHandle("setSpeed:");

		private static readonly IntPtr selTimeOffsetHandle = Selector.GetHandle("timeOffset");

		private static readonly IntPtr selSetTimeOffset_Handle = Selector.GetHandle("setTimeOffset:");

		private static readonly IntPtr selRepeatCountHandle = Selector.GetHandle("repeatCount");

		private static readonly IntPtr selSetRepeatCount_Handle = Selector.GetHandle("setRepeatCount:");

		private static readonly IntPtr selRepeatDurationHandle = Selector.GetHandle("repeatDuration");

		private static readonly IntPtr selSetRepeatDuration_Handle = Selector.GetHandle("setRepeatDuration:");

		private static readonly IntPtr selAutoreversesHandle = Selector.GetHandle("autoreverses");

		private static readonly IntPtr selSetAutoreverses_Handle = Selector.GetHandle("setAutoreverses:");

		private static readonly IntPtr selFillModeHandle = Selector.GetHandle("fillMode");

		private static readonly IntPtr selSetFillMode_Handle = Selector.GetHandle("setFillMode:");

		private static readonly IntPtr selShadowColorHandle = Selector.GetHandle("shadowColor");

		private static readonly IntPtr selSetShadowColor_Handle = Selector.GetHandle("setShadowColor:");

		private static readonly IntPtr selShadowOffsetHandle = Selector.GetHandle("shadowOffset");

		private static readonly IntPtr selSetShadowOffset_Handle = Selector.GetHandle("setShadowOffset:");

		private static readonly IntPtr selShadowOpacityHandle = Selector.GetHandle("shadowOpacity");

		private static readonly IntPtr selSetShadowOpacity_Handle = Selector.GetHandle("setShadowOpacity:");

		private static readonly IntPtr selShadowRadiusHandle = Selector.GetHandle("shadowRadius");

		private static readonly IntPtr selSetShadowRadius_Handle = Selector.GetHandle("setShadowRadius:");

		private static readonly IntPtr selVisibleRectHandle = Selector.GetHandle("visibleRect");

		private static readonly IntPtr selAutoresizingMaskHandle = Selector.GetHandle("autoresizingMask");

		private static readonly IntPtr selSetAutoresizingMask_Handle = Selector.GetHandle("setAutoresizingMask:");

		private static readonly IntPtr selConstraintsHandle = Selector.GetHandle("constraints");

		private static readonly IntPtr selSetConstraints_Handle = Selector.GetHandle("setConstraints:");

		private static readonly IntPtr selFiltersHandle = Selector.GetHandle("filters");

		private static readonly IntPtr selSetFilters_Handle = Selector.GetHandle("setFilters:");

		private static readonly IntPtr selLayerHandle = Selector.GetHandle("layer");

		private static readonly IntPtr selDefaultValueForKey_Handle = Selector.GetHandle("defaultValueForKey:");

		private static readonly IntPtr selNeedsDisplayForKey_Handle = Selector.GetHandle("needsDisplayForKey:");

		private static readonly IntPtr selRemoveFromSuperlayerHandle = Selector.GetHandle("removeFromSuperlayer");

		private static readonly IntPtr selAddSublayer_Handle = Selector.GetHandle("addSublayer:");

		private static readonly IntPtr selInsertSublayerAtIndex_Handle = Selector.GetHandle("insertSublayer:atIndex:");

		private static readonly IntPtr selInsertSublayerBelow_Handle = Selector.GetHandle("insertSublayer:below:");

		private static readonly IntPtr selInsertSublayerAbove_Handle = Selector.GetHandle("insertSublayer:above:");

		private static readonly IntPtr selReplaceSublayerWith_Handle = Selector.GetHandle("replaceSublayer:with:");

		private static readonly IntPtr selConvertPointFromLayer_Handle = Selector.GetHandle("convertPoint:fromLayer:");

		private static readonly IntPtr selConvertPointToLayer_Handle = Selector.GetHandle("convertPoint:toLayer:");

		private static readonly IntPtr selConvertRectFromLayer_Handle = Selector.GetHandle("convertRect:fromLayer:");

		private static readonly IntPtr selConvertRectToLayer_Handle = Selector.GetHandle("convertRect:toLayer:");

		private static readonly IntPtr selConvertTimeFromLayer_Handle = Selector.GetHandle("convertTime:fromLayer:");

		private static readonly IntPtr selConvertTimeToLayer_Handle = Selector.GetHandle("convertTime:toLayer:");

		private static readonly IntPtr selHitTest_Handle = Selector.GetHandle("hitTest:");

		private static readonly IntPtr selContainsPoint_Handle = Selector.GetHandle("containsPoint:");

		private static readonly IntPtr selDisplayHandle = Selector.GetHandle("display");

		private static readonly IntPtr selSetNeedsDisplayHandle = Selector.GetHandle("setNeedsDisplay");

		private static readonly IntPtr selSetNeedsDisplayInRect_Handle = Selector.GetHandle("setNeedsDisplayInRect:");

		private static readonly IntPtr selDisplayIfNeededHandle = Selector.GetHandle("displayIfNeeded");

		private static readonly IntPtr selDrawInContext_Handle = Selector.GetHandle("drawInContext:");

		private static readonly IntPtr selRenderInContext_Handle = Selector.GetHandle("renderInContext:");

		private static readonly IntPtr selPreferredFrameSizeHandle = Selector.GetHandle("preferredFrameSize");

		private static readonly IntPtr selSetNeedsLayoutHandle = Selector.GetHandle("setNeedsLayout");

		private static readonly IntPtr selNeedsLayoutHandle = Selector.GetHandle("needsLayout");

		private static readonly IntPtr selLayoutIfNeededHandle = Selector.GetHandle("layoutIfNeeded");

		private static readonly IntPtr selLayoutSublayersHandle = Selector.GetHandle("layoutSublayers");

		private static readonly IntPtr selDefaultActionForKey_Handle = Selector.GetHandle("defaultActionForKey:");

		private static readonly IntPtr selActionForKey_Handle = Selector.GetHandle("actionForKey:");

		private static readonly IntPtr selAddAnimationForKey_Handle = Selector.GetHandle("addAnimation:forKey:");

		private static readonly IntPtr selRemoveAllAnimationsHandle = Selector.GetHandle("removeAllAnimations");

		private static readonly IntPtr selRemoveAnimationForKey_Handle = Selector.GetHandle("removeAnimationForKey:");

		private static readonly IntPtr selAnimationForKey_Handle = Selector.GetHandle("animationForKey:");

		private static readonly IntPtr selScrollPoint_Handle = Selector.GetHandle("scrollPoint:");

		private static readonly IntPtr selScrollRectToVisible_Handle = Selector.GetHandle("scrollRectToVisible:");

		private static readonly IntPtr selResizeSublayersWithOldSize_Handle = Selector.GetHandle("resizeSublayersWithOldSize:");

		private static readonly IntPtr selResizeWithOldSuperlayerSize_Handle = Selector.GetHandle("resizeWithOldSuperlayerSize:");

		private static readonly IntPtr selAddConstraint_Handle = Selector.GetHandle("addConstraint:");

		private static readonly IntPtr class_ptr = Class.GetHandle("CALayer");

		private object __mt_PresentationLayer_var;

		private object __mt_ModelLayer_var;

		private object __mt_SuperLayer_var;

		private object __mt_Sublayers_var;

		private object __mt_Mask_var;

		private object __mt_LayoutManager_var;

		private object __mt_Actions_var;

		private object __mt_WeakDelegate_var;

		private object __mt_Constraints_var;

		private object __mt_Filters_var;

		private static NSString _Transition;

		private static NSString _GravityCenter;

		private static NSString _GravityTop;

		private static NSString _GravityBottom;

		private static NSString _GravityLeft;

		private static NSString _GravityRight;

		private static NSString _GravityTopLeft;

		private static NSString _GravityTopRight;

		private static NSString _GravityBottomLeft;

		private static NSString _GravityBottomRight;

		private static NSString _GravityResize;

		private static NSString _GravityResizeAspect;

		private static NSString _GravityResizeAspectFill;

		private static NSString _FilterNearest;

		private static NSString _FilterLinear;

		private static NSString _FilterTrilinear;

		private static NSString _OnOrderIn;

		private static NSString _OnOrderOut;

		[Obsolete("Use BeginTime instead")]
		public double CFTimeInterval
		{
			get
			{
				return BeginTime;
			}
			set
			{
				BeginTime = value;
			}
		}

		public override IntPtr ClassHandle => class_ptr;

		public virtual CALayer PresentationLayer
		{
			[Export("presentationLayer")]
			get
			{
				return (CALayer)(__mt_PresentationLayer_var = ((!IsDirectBinding) ? ((CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selPresentationLayerHandle))) : ((CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selPresentationLayerHandle)))));
			}
		}

		public virtual CALayer ModelLayer
		{
			[Export("modelLayer")]
			get
			{
				return (CALayer)(__mt_ModelLayer_var = ((!IsDirectBinding) ? ((CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selModelLayerHandle))) : ((CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selModelLayerHandle)))));
			}
		}

		public virtual CGRect Bounds
		{
			[Export("bounds")]
			get
			{
				CGRect retval;
				if (IsDirectBinding)
				{
					Messaging.CGRect_objc_msgSend_stret(out retval, base.Handle, selBoundsHandle);
				}
				else
				{
					Messaging.CGRect_objc_msgSendSuper_stret(out retval, base.SuperHandle, selBoundsHandle);
				}
				return retval;
			}
			[Export("setBounds:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CGRect(base.Handle, selSetBounds_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CGRect(base.SuperHandle, selSetBounds_Handle, value);
				}
			}
		}

		public virtual double ZPosition
		{
			[Export("zPosition")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selZPositionHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selZPositionHandle);
			}
			[Export("setZPosition:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetZPosition_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetZPosition_Handle, value);
				}
			}
		}

		public virtual CGPoint AnchorPoint
		{
			[Export("anchorPoint")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.CGPoint_objc_msgSend(base.Handle, selAnchorPointHandle);
				}
				return Messaging.CGPoint_objc_msgSendSuper(base.SuperHandle, selAnchorPointHandle);
			}
			[Export("setAnchorPoint:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CGPoint(base.Handle, selSetAnchorPoint_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CGPoint(base.SuperHandle, selSetAnchorPoint_Handle, value);
				}
			}
		}

		public virtual double AnchorPointZ
		{
			[Export("anchorPointZ")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selAnchorPointZHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selAnchorPointZHandle);
			}
			[Export("setAnchorPointZ:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetAnchorPointZ_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetAnchorPointZ_Handle, value);
				}
			}
		}

		public virtual CGPoint Position
		{
			[Export("position")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.CGPoint_objc_msgSend(base.Handle, selPositionHandle);
				}
				return Messaging.CGPoint_objc_msgSendSuper(base.SuperHandle, selPositionHandle);
			}
			[Export("setPosition:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CGPoint(base.Handle, selSetPosition_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CGPoint(base.SuperHandle, selSetPosition_Handle, value);
				}
			}
		}

		public virtual CATransform3D Transform
		{
			[Export("transform")]
			get
			{
				CATransform3D retval;
				if (IsDirectBinding)
				{
					Messaging.CATransform3D_objc_msgSend_stret(out retval, base.Handle, selTransformHandle);
				}
				else
				{
					Messaging.CATransform3D_objc_msgSendSuper_stret(out retval, base.SuperHandle, selTransformHandle);
				}
				return retval;
			}
			[Export("setTransform:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CATransform3D(base.Handle, selSetTransform_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CATransform3D(base.SuperHandle, selSetTransform_Handle, value);
				}
			}
		}

		public virtual CGAffineTransform AffineTransform
		{
			[Export("affineTransform")]
			get
			{
				CGAffineTransform retval;
				if (IsDirectBinding)
				{
					Messaging.CGAffineTransform_objc_msgSend_stret(out retval, base.Handle, selAffineTransformHandle);
				}
				else
				{
					Messaging.CGAffineTransform_objc_msgSendSuper_stret(out retval, base.SuperHandle, selAffineTransformHandle);
				}
				return retval;
			}
			[Export("setAffineTransform:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CGAffineTransform(base.Handle, selSetAffineTransform_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CGAffineTransform(base.SuperHandle, selSetAffineTransform_Handle, value);
				}
			}
		}

		public virtual CGRect Frame
		{
			[Export("frame")]
			get
			{
				CGRect retval;
				if (IsDirectBinding)
				{
					Messaging.CGRect_objc_msgSend_stret(out retval, base.Handle, selFrameHandle);
				}
				else
				{
					Messaging.CGRect_objc_msgSendSuper_stret(out retval, base.SuperHandle, selFrameHandle);
				}
				return retval;
			}
			[Export("setFrame:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CGRect(base.Handle, selSetFrame_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CGRect(base.SuperHandle, selSetFrame_Handle, value);
				}
			}
		}

		public virtual bool Hidden
		{
			[Export("isHidden")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selIsHiddenHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsHiddenHandle);
			}
			[Export("setHidden:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_bool(base.Handle, selSetHidden_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetHidden_Handle, value);
				}
			}
		}

		public virtual bool DoubleSided
		{
			[Export("isDoubleSided")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selIsDoubleSidedHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsDoubleSidedHandle);
			}
			[Export("setDoubleSided:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_bool(base.Handle, selSetDoubleSided_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetDoubleSided_Handle, value);
				}
			}
		}

		public virtual bool GeometryFlipped
		{
			[Export("isGeometryFlipped")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selIsGeometryFlippedHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsGeometryFlippedHandle);
			}
			[Export("setGeometryFlipped:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_bool(base.Handle, selSetGeometryFlipped_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetGeometryFlipped_Handle, value);
				}
			}
		}

		public virtual bool ContentsAreFlipped
		{
			[Export("contentsAreFlipped")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selContentsAreFlippedHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selContentsAreFlippedHandle);
			}
		}

		public virtual CALayer SuperLayer
		{
			[Export("superlayer")]
			get
			{
				return (CALayer)(__mt_SuperLayer_var = ((!IsDirectBinding) ? ((CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selSuperlayerHandle))) : ((CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selSuperlayerHandle)))));
			}
		}

		public virtual CALayer[] Sublayers
		{
			[Export("sublayers", ArgumentSemantic.Copy)]
			get
			{
				return (CALayer[])(__mt_Sublayers_var = ((!IsDirectBinding) ? NSArray.ArrayFromHandle<CALayer>(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selSublayersHandle)) : NSArray.ArrayFromHandle<CALayer>(Messaging.IntPtr_objc_msgSend(base.Handle, selSublayersHandle))));
			}
			[Export("setSublayers:", ArgumentSemantic.Copy)]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				NSArray nSArray = NSArray.FromNSObjects(value);
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetSublayers_Handle, nSArray.Handle);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetSublayers_Handle, nSArray.Handle);
				}
				nSArray.Dispose();
				__mt_Sublayers_var = value;
			}
		}

		public virtual CATransform3D SublayerTransform
		{
			[Export("sublayerTransform")]
			get
			{
				CATransform3D retval;
				if (IsDirectBinding)
				{
					Messaging.CATransform3D_objc_msgSend_stret(out retval, base.Handle, selSublayerTransformHandle);
				}
				else
				{
					Messaging.CATransform3D_objc_msgSendSuper_stret(out retval, base.SuperHandle, selSublayerTransformHandle);
				}
				return retval;
			}
			[Export("setSublayerTransform:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CATransform3D(base.Handle, selSetSublayerTransform_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CATransform3D(base.SuperHandle, selSetSublayerTransform_Handle, value);
				}
			}
		}

		public virtual CALayer Mask
		{
			[Export("mask", ArgumentSemantic.Retain)]
			get
			{
				return (CALayer)(__mt_Mask_var = ((!IsDirectBinding) ? ((CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selMaskHandle))) : ((CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selMaskHandle)))));
			}
			[Export("setMask:", ArgumentSemantic.Retain)]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetMask_Handle, value?.Handle ?? IntPtr.Zero);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetMask_Handle, value?.Handle ?? IntPtr.Zero);
				}
				__mt_Mask_var = value;
			}
		}

		public virtual bool MasksToBounds
		{
			[Export("masksToBounds")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selMasksToBoundsHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selMasksToBoundsHandle);
			}
			[Export("setMasksToBounds:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_bool(base.Handle, selSetMasksToBounds_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetMasksToBounds_Handle, value);
				}
			}
		}

		public virtual CGImage Contents
		{
			[Export("contents", ArgumentSemantic.Retain)]
			get
			{
				if (IsDirectBinding)
				{
					return new CGImage(Messaging.IntPtr_objc_msgSend(base.Handle, selContentsHandle));
				}
				return new CGImage(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selContentsHandle));
			}
			[Export("setContents:", ArgumentSemantic.Retain)]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetContents_Handle, value?.Handle ?? IntPtr.Zero);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetContents_Handle, value?.Handle ?? IntPtr.Zero);
				}
			}
		}

		public virtual NSObject LayoutManager
		{
			[Export("layoutManager")]
			get
			{
				return (NSObject)(__mt_LayoutManager_var = ((!IsDirectBinding) ? Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selLayoutManagerHandle)) : Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selLayoutManagerHandle))));
			}
			[Export("setLayoutManager:")]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetLayoutManager_Handle, value.Handle);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetLayoutManager_Handle, value.Handle);
				}
				__mt_LayoutManager_var = value;
			}
		}

		public virtual double ContentsScale
		{
			[Export("contentsScale")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selContentsScaleHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selContentsScaleHandle);
			}
			[Export("setContentsScale:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetContentsScale_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetContentsScale_Handle, value);
				}
			}
		}

		public virtual CGRect ContentsRect
		{
			[Export("contentsRect")]
			get
			{
				CGRect retval;
				if (IsDirectBinding)
				{
					Messaging.CGRect_objc_msgSend_stret(out retval, base.Handle, selContentsRectHandle);
				}
				else
				{
					Messaging.CGRect_objc_msgSendSuper_stret(out retval, base.SuperHandle, selContentsRectHandle);
				}
				return retval;
			}
			[Export("setContentsRect:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CGRect(base.Handle, selSetContentsRect_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CGRect(base.SuperHandle, selSetContentsRect_Handle, value);
				}
			}
		}

		public virtual string ContentsGravity
		{
			[Export("contentsGravity", ArgumentSemantic.Copy)]
			get
			{
				if (IsDirectBinding)
				{
					return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selContentsGravityHandle));
				}
				return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selContentsGravityHandle));
			}
			[Export("setContentsGravity:", ArgumentSemantic.Copy)]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				IntPtr intPtr = NSString.CreateNative(value);
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetContentsGravity_Handle, intPtr);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetContentsGravity_Handle, intPtr);
				}
				NSString.ReleaseNative(intPtr);
			}
		}

		public virtual CGRect ContentsCenter
		{
			[Export("contentsCenter")]
			get
			{
				CGRect retval;
				if (IsDirectBinding)
				{
					Messaging.CGRect_objc_msgSend_stret(out retval, base.Handle, selContentsCenterHandle);
				}
				else
				{
					Messaging.CGRect_objc_msgSendSuper_stret(out retval, base.SuperHandle, selContentsCenterHandle);
				}
				return retval;
			}
			[Export("setContentsCenter:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CGRect(base.Handle, selSetContentsCenter_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CGRect(base.SuperHandle, selSetContentsCenter_Handle, value);
				}
			}
		}

		public virtual string MinificationFilter
		{
			[Export("minificationFilter", ArgumentSemantic.Copy)]
			get
			{
				if (IsDirectBinding)
				{
					return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selMinificationFilterHandle));
				}
				return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selMinificationFilterHandle));
			}
			[Export("setMinificationFilter:", ArgumentSemantic.Copy)]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				IntPtr intPtr = NSString.CreateNative(value);
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetMinificationFilter_Handle, intPtr);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetMinificationFilter_Handle, intPtr);
				}
				NSString.ReleaseNative(intPtr);
			}
		}

		public virtual string MagnificationFilter
		{
			[Export("magnificationFilter", ArgumentSemantic.Copy)]
			get
			{
				if (IsDirectBinding)
				{
					return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selMagnificationFilterHandle));
				}
				return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selMagnificationFilterHandle));
			}
			[Export("setMagnificationFilter:", ArgumentSemantic.Copy)]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				IntPtr intPtr = NSString.CreateNative(value);
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetMagnificationFilter_Handle, intPtr);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetMagnificationFilter_Handle, intPtr);
				}
				NSString.ReleaseNative(intPtr);
			}
		}

		public virtual bool Opaque
		{
			[Export("isOpaque")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selIsOpaqueHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsOpaqueHandle);
			}
			[Export("setOpaque:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_bool(base.Handle, selSetOpaque_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetOpaque_Handle, value);
				}
			}
		}

		public virtual bool NeedsDisplay
		{
			[Export("needsDisplay")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selNeedsDisplayHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selNeedsDisplayHandle);
			}
		}

		public virtual bool NeedsDisplayOnBoundsChange
		{
			[Export("needsDisplayOnBoundsChange")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selNeedsDisplayOnBoundsChangeHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selNeedsDisplayOnBoundsChangeHandle);
			}
			[Export("setNeedsDisplayOnBoundsChange:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_bool(base.Handle, selSetNeedsDisplayOnBoundsChange_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetNeedsDisplayOnBoundsChange_Handle, value);
				}
			}
		}

		public virtual CGColor BackgroundColor
		{
			[Export("backgroundColor")]
			get
			{
				if (IsDirectBinding)
				{
					return new CGColor(Messaging.IntPtr_objc_msgSend(base.Handle, selBackgroundColorHandle));
				}
				return new CGColor(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selBackgroundColorHandle));
			}
			[Export("setBackgroundColor:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetBackgroundColor_Handle, value.Handle);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetBackgroundColor_Handle, value.Handle);
				}
			}
		}

		public virtual double CornerRadius
		{
			[Export("cornerRadius")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selCornerRadiusHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selCornerRadiusHandle);
			}
			[Export("setCornerRadius:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetCornerRadius_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetCornerRadius_Handle, value);
				}
			}
		}

		public virtual double BorderWidth
		{
			[Export("borderWidth")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selBorderWidthHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selBorderWidthHandle);
			}
			[Export("setBorderWidth:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetBorderWidth_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetBorderWidth_Handle, value);
				}
			}
		}

		public virtual CGColor BorderColor
		{
			[Export("borderColor")]
			get
			{
				if (IsDirectBinding)
				{
					return new CGColor(Messaging.IntPtr_objc_msgSend(base.Handle, selBorderColorHandle));
				}
				return new CGColor(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selBorderColorHandle));
			}
			[Export("setBorderColor:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetBorderColor_Handle, value.Handle);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetBorderColor_Handle, value.Handle);
				}
			}
		}

		public virtual float Opacity
		{
			[Export("opacity")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.float_objc_msgSend(base.Handle, selOpacityHandle);
				}
				return Messaging.float_objc_msgSendSuper(base.SuperHandle, selOpacityHandle);
			}
			[Export("setOpacity:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_float(base.Handle, selSetOpacity_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_float(base.SuperHandle, selSetOpacity_Handle, value);
				}
			}
		}

		public virtual CAEdgeAntialiasingMask EdgeAntialiasingMask
		{
			[Export("edgeAntialiasingMask")]
			get
			{
				if (IsDirectBinding)
				{
					return (CAEdgeAntialiasingMask)Messaging.int_objc_msgSend(base.Handle, selEdgeAntialiasingMaskHandle);
				}
				return (CAEdgeAntialiasingMask)Messaging.int_objc_msgSendSuper(base.SuperHandle, selEdgeAntialiasingMaskHandle);
			}
			[Export("setEdgeAntialiasingMask:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_int(base.Handle, selSetEdgeAntialiasingMask_Handle, (int)value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_int(base.SuperHandle, selSetEdgeAntialiasingMask_Handle, (int)value);
				}
			}
		}

		public virtual NSDictionary Actions
		{
			[Export("actions", ArgumentSemantic.Copy)]
			get
			{
				return (NSDictionary)(__mt_Actions_var = ((!IsDirectBinding) ? ((NSDictionary)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selActionsHandle))) : ((NSDictionary)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selActionsHandle)))));
			}
			[Export("setActions:", ArgumentSemantic.Copy)]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetActions_Handle, value.Handle);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetActions_Handle, value.Handle);
				}
				__mt_Actions_var = value;
			}
		}

		public virtual string[] AnimationKeys
		{
			[Export("animationKeys")]
			get
			{
				if (IsDirectBinding)
				{
					return NSArray.StringArrayFromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selAnimationKeysHandle));
				}
				return NSArray.StringArrayFromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selAnimationKeysHandle));
			}
		}

		public virtual string Name
		{
			[Export("name", ArgumentSemantic.Copy)]
			get
			{
				if (IsDirectBinding)
				{
					return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selNameHandle));
				}
				return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selNameHandle));
			}
			[Export("setName:", ArgumentSemantic.Copy)]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				IntPtr intPtr = NSString.CreateNative(value);
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetName_Handle, intPtr);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetName_Handle, intPtr);
				}
				NSString.ReleaseNative(intPtr);
			}
		}

		public virtual NSObject WeakDelegate
		{
			[Export("delegate", ArgumentSemantic.Assign)]
			get
			{
				return (NSObject)(__mt_WeakDelegate_var = ((!IsDirectBinding) ? Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selDelegateHandle)) : Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selDelegateHandle))));
			}
			[Export("setDelegate:", ArgumentSemantic.Assign)]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetDelegate_Handle, value?.Handle ?? IntPtr.Zero);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetDelegate_Handle, value?.Handle ?? IntPtr.Zero);
				}
				__mt_WeakDelegate_var = value;
			}
		}

		public CALayerDelegate Delegate
		{
			get
			{
				return WeakDelegate as CALayerDelegate;
			}
			set
			{
				WeakDelegate = value;
			}
		}

		public virtual double BeginTime
		{
			[Export("beginTime")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selBeginTimeHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selBeginTimeHandle);
			}
			[Export("setBeginTime:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetBeginTime_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetBeginTime_Handle, value);
				}
			}
		}

		public virtual double Duration
		{
			[Export("duration")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selDurationHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selDurationHandle);
			}
			[Export("setDuration:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetDuration_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetDuration_Handle, value);
				}
			}
		}

		public virtual float Speed
		{
			[Export("speed")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.float_objc_msgSend(base.Handle, selSpeedHandle);
				}
				return Messaging.float_objc_msgSendSuper(base.SuperHandle, selSpeedHandle);
			}
			[Export("setSpeed:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_float(base.Handle, selSetSpeed_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_float(base.SuperHandle, selSetSpeed_Handle, value);
				}
			}
		}

		public virtual double TimeOffset
		{
			[Export("timeOffset")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selTimeOffsetHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selTimeOffsetHandle);
			}
			[Export("setTimeOffset:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetTimeOffset_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetTimeOffset_Handle, value);
				}
			}
		}

		public virtual float RepeatCount
		{
			[Export("repeatCount")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.float_objc_msgSend(base.Handle, selRepeatCountHandle);
				}
				return Messaging.float_objc_msgSendSuper(base.SuperHandle, selRepeatCountHandle);
			}
			[Export("setRepeatCount:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_float(base.Handle, selSetRepeatCount_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_float(base.SuperHandle, selSetRepeatCount_Handle, value);
				}
			}
		}

		public virtual double RepeatDuration
		{
			[Export("repeatDuration")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selRepeatDurationHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selRepeatDurationHandle);
			}
			[Export("setRepeatDuration:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetRepeatDuration_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetRepeatDuration_Handle, value);
				}
			}
		}

		public virtual bool AutoReverses
		{
			[Export("autoreverses")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selAutoreversesHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selAutoreversesHandle);
			}
			[Export("setAutoreverses:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_bool(base.Handle, selSetAutoreverses_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetAutoreverses_Handle, value);
				}
			}
		}

		public virtual string FillMode
		{
			[Export("fillMode")]
			get
			{
				if (IsDirectBinding)
				{
					return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selFillModeHandle));
				}
				return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selFillModeHandle));
			}
			[Export("setFillMode:")]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				IntPtr intPtr = NSString.CreateNative(value);
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetFillMode_Handle, intPtr);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetFillMode_Handle, intPtr);
				}
				NSString.ReleaseNative(intPtr);
			}
		}

		[Since(3, 2)]
		public virtual CGColor ShadowColor
		{
			[Export("shadowColor")]
			get
			{
				if (IsDirectBinding)
				{
					return new CGColor(Messaging.IntPtr_objc_msgSend(base.Handle, selShadowColorHandle));
				}
				return new CGColor(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selShadowColorHandle));
			}
			[Export("setShadowColor:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetShadowColor_Handle, value.Handle);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetShadowColor_Handle, value.Handle);
				}
			}
		}

		[Since(3, 2)]
		public virtual CGSize ShadowOffset
		{
			[Export("shadowOffset")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.CGSize_objc_msgSend(base.Handle, selShadowOffsetHandle);
				}
				return Messaging.CGSize_objc_msgSendSuper(base.SuperHandle, selShadowOffsetHandle);
			}
			[Export("setShadowOffset:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_CGSize(base.Handle, selSetShadowOffset_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_CGSize(base.SuperHandle, selSetShadowOffset_Handle, value);
				}
			}
		}

		[Since(3, 2)]
		public virtual float ShadowOpacity
		{
			[Export("shadowOpacity")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.float_objc_msgSend(base.Handle, selShadowOpacityHandle);
				}
				return Messaging.float_objc_msgSendSuper(base.SuperHandle, selShadowOpacityHandle);
			}
			[Export("setShadowOpacity:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_float(base.Handle, selSetShadowOpacity_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_float(base.SuperHandle, selSetShadowOpacity_Handle, value);
				}
			}
		}

		[Since(3, 2)]
		public virtual double ShadowRadius
		{
			[Export("shadowRadius")]
			get
			{
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selShadowRadiusHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selShadowRadiusHandle);
			}
			[Export("setShadowRadius:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_Double(base.Handle, selSetShadowRadius_Handle, value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetShadowRadius_Handle, value);
				}
			}
		}

		public virtual CGRect VisibleRect
		{
			[Export("visibleRect")]
			get
			{
				CGRect retval;
				if (IsDirectBinding)
				{
					Messaging.CGRect_objc_msgSend_stret(out retval, base.Handle, selVisibleRectHandle);
				}
				else
				{
					Messaging.CGRect_objc_msgSendSuper_stret(out retval, base.SuperHandle, selVisibleRectHandle);
				}
				return retval;
			}
		}

		public virtual CAAutoresizingMask AutoresizinMask
		{
			[Export("autoresizingMask")]
			get
			{
				if (IsDirectBinding)
				{
					return (CAAutoresizingMask)Messaging.int_objc_msgSend(base.Handle, selAutoresizingMaskHandle);
				}
				return (CAAutoresizingMask)Messaging.int_objc_msgSendSuper(base.SuperHandle, selAutoresizingMaskHandle);
			}
			[Export("setAutoresizingMask:")]
			set
			{
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_int(base.Handle, selSetAutoresizingMask_Handle, (int)value);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_int(base.SuperHandle, selSetAutoresizingMask_Handle, (int)value);
				}
			}
		}

		public virtual CAConstraint[] Constraints
		{
			[Export("constraints")]
			get
			{
				return (CAConstraint[])(__mt_Constraints_var = ((!IsDirectBinding) ? NSArray.ArrayFromHandle<CAConstraint>(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selConstraintsHandle)) : NSArray.ArrayFromHandle<CAConstraint>(Messaging.IntPtr_objc_msgSend(base.Handle, selConstraintsHandle))));
			}
			[Export("setConstraints:")]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				NSArray nSArray = NSArray.FromNSObjects(value);
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetConstraints_Handle, nSArray.Handle);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetConstraints_Handle, nSArray.Handle);
				}
				nSArray.Dispose();
				__mt_Constraints_var = value;
			}
		}

		public virtual CIFilter[] Filters
		{
			[Export("filters")]
			get
			{
				return (CIFilter[])(__mt_Filters_var = ((!IsDirectBinding) ? NSArray.ArrayFromHandle<CIFilter>(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selFiltersHandle)) : NSArray.ArrayFromHandle<CIFilter>(Messaging.IntPtr_objc_msgSend(base.Handle, selFiltersHandle))));
			}
			[Export("setFilters:")]
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				NSArray nSArray = NSArray.FromNSObjects(value);
				if (IsDirectBinding)
				{
					Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetFilters_Handle, nSArray.Handle);
				}
				else
				{
					Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetFilters_Handle, nSArray.Handle);
				}
				nSArray.Dispose();
				__mt_Filters_var = value;
			}
		}

		[Field("kCATransition", "CoreAnimation")]
		public static NSString Transition
		{
			get
			{
				if (_Transition == null)
				{
					_Transition = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCATransition");
				}
				return _Transition;
			}
		}

		[Field("kCAGravityCenter", "CoreAnimation")]
		public static NSString GravityCenter
		{
			get
			{
				if (_GravityCenter == null)
				{
					_GravityCenter = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityCenter");
				}
				return _GravityCenter;
			}
		}

		[Field("kCAGravityTop", "CoreAnimation")]
		public static NSString GravityTop
		{
			get
			{
				if (_GravityTop == null)
				{
					_GravityTop = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityTop");
				}
				return _GravityTop;
			}
		}

		[Field("kCAGravityBottom", "CoreAnimation")]
		public static NSString GravityBottom
		{
			get
			{
				if (_GravityBottom == null)
				{
					_GravityBottom = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityBottom");
				}
				return _GravityBottom;
			}
		}

		[Field("kCAGravityLeft", "CoreAnimation")]
		public static NSString GravityLeft
		{
			get
			{
				if (_GravityLeft == null)
				{
					_GravityLeft = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityLeft");
				}
				return _GravityLeft;
			}
		}

		[Field("kCAGravityRight", "CoreAnimation")]
		public static NSString GravityRight
		{
			get
			{
				if (_GravityRight == null)
				{
					_GravityRight = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityRight");
				}
				return _GravityRight;
			}
		}

		[Field("kCAGravityTopLeft", "CoreAnimation")]
		public static NSString GravityTopLeft
		{
			get
			{
				if (_GravityTopLeft == null)
				{
					_GravityTopLeft = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityTopLeft");
				}
				return _GravityTopLeft;
			}
		}

		[Field("kCAGravityTopRight", "CoreAnimation")]
		public static NSString GravityTopRight
		{
			get
			{
				if (_GravityTopRight == null)
				{
					_GravityTopRight = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityTopRight");
				}
				return _GravityTopRight;
			}
		}

		[Field("kCAGravityBottomLeft", "CoreAnimation")]
		public static NSString GravityBottomLeft
		{
			get
			{
				if (_GravityBottomLeft == null)
				{
					_GravityBottomLeft = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityBottomLeft");
				}
				return _GravityBottomLeft;
			}
		}

		[Field("kCAGravityBottomRight", "CoreAnimation")]
		public static NSString GravityBottomRight
		{
			get
			{
				if (_GravityBottomRight == null)
				{
					_GravityBottomRight = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityBottomRight");
				}
				return _GravityBottomRight;
			}
		}

		[Field("kCAGravityResize", "CoreAnimation")]
		public static NSString GravityResize
		{
			get
			{
				if (_GravityResize == null)
				{
					_GravityResize = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityResize");
				}
				return _GravityResize;
			}
		}

		[Field("kCAGravityResizeAspect", "CoreAnimation")]
		public static NSString GravityResizeAspect
		{
			get
			{
				if (_GravityResizeAspect == null)
				{
					_GravityResizeAspect = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityResizeAspect");
				}
				return _GravityResizeAspect;
			}
		}

		[Field("kCAGravityResizeAspectFill", "CoreAnimation")]
		public static NSString GravityResizeAspectFill
		{
			get
			{
				if (_GravityResizeAspectFill == null)
				{
					_GravityResizeAspectFill = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAGravityResizeAspectFill");
				}
				return _GravityResizeAspectFill;
			}
		}

		[Field("kCAFilterNearest", "CoreAnimation")]
		public static NSString FilterNearest
		{
			get
			{
				if (_FilterNearest == null)
				{
					_FilterNearest = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAFilterNearest");
				}
				return _FilterNearest;
			}
		}

		[Field("kCAFilterLinear", "CoreAnimation")]
		public static NSString FilterLinear
		{
			get
			{
				if (_FilterLinear == null)
				{
					_FilterLinear = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAFilterLinear");
				}
				return _FilterLinear;
			}
		}

		[Field("kCAFilterTrilinear", "CoreAnimation")]
		public static NSString FilterTrilinear
		{
			get
			{
				if (_FilterTrilinear == null)
				{
					_FilterTrilinear = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAFilterTrilinear");
				}
				return _FilterTrilinear;
			}
		}

		[Field("kCAOnOrderIn", "CoreAnimation")]
		public static NSString OnOrderIn
		{
			get
			{
				if (_OnOrderIn == null)
				{
					_OnOrderIn = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAOnOrderIn");
				}
				return _OnOrderIn;
			}
		}

		[Field("kCAOnOrderOut", "CoreAnimation")]
		public static NSString OnOrderOut
		{
			get
			{
				if (_OnOrderOut == null)
				{
					_OnOrderOut = Dlfcn.GetStringConstant(Libraries.CoreAnimation.Handle, "kCAOnOrderOut");
				}
				return _OnOrderOut;
			}
		}

		[Export("initWithLayer:")]
		public CALayer(CALayer other)
		{
			if (GetType() == typeof(CALayer))
			{
				Messaging.intptr_objc_msgSend_intptr(base.Handle, Selector.GetHandle("initWithLayer:"), other.Handle);
				return;
			}
			Messaging.intptr_objc_msgSendSuper_intptr(base.SuperHandle, Selector.GetHandle("initWithLayer:"), other.Handle);
			Clone(other);
		}

		public virtual void Clone(CALayer other)
		{
		}

		[Obsolete("Use ConvertRectFromLayer instead")]
		public CGRect ConvertRectfromLayer(CGRect rect, CALayer layer)
		{
			return ConvertRectFromLayer(rect, layer);
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		[Export("init")]
		public CALayer()
			: base(NSObjectFlag.Empty)
		{
			if (IsDirectBinding)
			{
				base.Handle = Messaging.IntPtr_objc_msgSend(base.Handle, Selector.Init);
			}
			else
			{
				base.Handle = Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, Selector.Init);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		[Export("initWithCoder:")]
		public CALayer(NSCoder coder)
			: base(NSObjectFlag.Empty)
		{
			if (IsDirectBinding)
			{
				base.Handle = Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, Selector.InitWithCoder, coder.Handle);
			}
			else
			{
				base.Handle = Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, Selector.InitWithCoder, coder.Handle);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public CALayer(NSObjectFlag t)
			: base(t)
		{
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public CALayer(IntPtr handle)
			: base(handle)
		{
		}

		[Export("layer")]
		public static CALayer Create()
		{
			return (CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(class_ptr, selLayerHandle));
		}

		[Export("defaultValueForKey:")]
		public static NSObject DefaultValue(string key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			IntPtr intPtr = NSString.CreateNative(key);
			NSObject nSObject = Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(class_ptr, selDefaultValueForKey_Handle, intPtr));
			NSString.ReleaseNative(intPtr);
			return nSObject;
		}

		[Export("needsDisplayForKey:")]
		public static bool NeedsDisplayForKey(string key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			IntPtr intPtr = NSString.CreateNative(key);
			bool result = Messaging.bool_objc_msgSend_IntPtr(class_ptr, selNeedsDisplayForKey_Handle, intPtr);
			NSString.ReleaseNative(intPtr);
			return result;
		}

		[Export("removeFromSuperlayer")]
		public virtual void RemoveFromSuperLayer()
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend(base.Handle, selRemoveFromSuperlayerHandle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper(base.SuperHandle, selRemoveFromSuperlayerHandle);
			}
		}

		[Export("addSublayer:")]
		public virtual void AddSublayer(CALayer layer)
		{
			if (layer == null)
			{
				throw new ArgumentNullException("layer");
			}
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr(base.Handle, selAddSublayer_Handle, layer.Handle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selAddSublayer_Handle, layer.Handle);
			}
			_ = Sublayers;
		}

		[Export("insertSublayer:atIndex:")]
		public virtual void InsertSublayer(CALayer layer, int index)
		{
			if (layer == null)
			{
				throw new ArgumentNullException("layer");
			}
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr_int(base.Handle, selInsertSublayerAtIndex_Handle, layer.Handle, index);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr_int(base.SuperHandle, selInsertSublayerAtIndex_Handle, layer.Handle, index);
			}
			_ = Sublayers;
		}

		[Export("insertSublayer:below:")]
		public virtual void InsertSublayerBelow(CALayer layer, CALayer sibling)
		{
			if (layer == null)
			{
				throw new ArgumentNullException("layer");
			}
			if (sibling == null)
			{
				throw new ArgumentNullException("sibling");
			}
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr_IntPtr(base.Handle, selInsertSublayerBelow_Handle, layer.Handle, sibling.Handle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selInsertSublayerBelow_Handle, layer.Handle, sibling.Handle);
			}
			_ = Sublayers;
		}

		[Export("insertSublayer:above:")]
		public virtual void InsertSublayerAbove(CALayer layer, CALayer sibling)
		{
			if (layer == null)
			{
				throw new ArgumentNullException("layer");
			}
			if (sibling == null)
			{
				throw new ArgumentNullException("sibling");
			}
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr_IntPtr(base.Handle, selInsertSublayerAbove_Handle, layer.Handle, sibling.Handle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selInsertSublayerAbove_Handle, layer.Handle, sibling.Handle);
			}
			_ = Sublayers;
		}

		[Export("replaceSublayer:with:")]
		public virtual void ReplaceSublayer(CALayer layer, CALayer with)
		{
			if (layer == null)
			{
				throw new ArgumentNullException("layer");
			}
			if (with == null)
			{
				throw new ArgumentNullException("with");
			}
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr_IntPtr(base.Handle, selReplaceSublayerWith_Handle, layer.Handle, with.Handle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selReplaceSublayerWith_Handle, layer.Handle, with.Handle);
			}
			_ = Sublayers;
		}

		[Export("convertPoint:fromLayer:")]
		public virtual CGPoint ConvertPointFromLayer(CGPoint point, CALayer layer)
		{
			if (IsDirectBinding)
			{
				return Messaging.CGPoint_objc_msgSend_CGPoint_IntPtr(base.Handle, selConvertPointFromLayer_Handle, point, layer?.Handle ?? IntPtr.Zero);
			}
			return Messaging.CGPoint_objc_msgSendSuper_CGPoint_IntPtr(base.SuperHandle, selConvertPointFromLayer_Handle, point, layer?.Handle ?? IntPtr.Zero);
		}

		[Export("convertPoint:toLayer:")]
		public virtual CGPoint ConvertPointToLayer(CGPoint point, CALayer layer)
		{
			if (IsDirectBinding)
			{
				return Messaging.CGPoint_objc_msgSend_CGPoint_IntPtr(base.Handle, selConvertPointToLayer_Handle, point, layer?.Handle ?? IntPtr.Zero);
			}
			return Messaging.CGPoint_objc_msgSendSuper_CGPoint_IntPtr(base.SuperHandle, selConvertPointToLayer_Handle, point, layer?.Handle ?? IntPtr.Zero);
		}

		[Export("convertRect:fromLayer:")]
		public virtual CGRect ConvertRectFromLayer(CGRect rect, CALayer layer)
		{
			CGRect retval;
			if (IsDirectBinding)
			{
				Messaging.CGRect_objc_msgSend_stret_CGRect_IntPtr(out retval, base.Handle, selConvertRectFromLayer_Handle, rect, layer?.Handle ?? IntPtr.Zero);
			}
			else
			{
				Messaging.CGRect_objc_msgSendSuper_stret_CGRect_IntPtr(out retval, base.SuperHandle, selConvertRectFromLayer_Handle, rect, layer?.Handle ?? IntPtr.Zero);
			}
			return retval;
		}

		[Export("convertRect:toLayer:")]
		public virtual CGRect ConvertRectToLayer(CGRect rect, CALayer layer)
		{
			CGRect retval;
			if (IsDirectBinding)
			{
				Messaging.CGRect_objc_msgSend_stret_CGRect_IntPtr(out retval, base.Handle, selConvertRectToLayer_Handle, rect, layer?.Handle ?? IntPtr.Zero);
			}
			else
			{
				Messaging.CGRect_objc_msgSendSuper_stret_CGRect_IntPtr(out retval, base.SuperHandle, selConvertRectToLayer_Handle, rect, layer?.Handle ?? IntPtr.Zero);
			}
			return retval;
		}

		[Export("convertTime:fromLayer:")]
		public virtual double ConvertTimeFromLayer(double timeInterval, CALayer layer)
		{
			if (IsDirectBinding)
			{
				return Messaging.Double_objc_msgSend_Double_IntPtr(base.Handle, selConvertTimeFromLayer_Handle, timeInterval, layer?.Handle ?? IntPtr.Zero);
			}
			return Messaging.Double_objc_msgSendSuper_Double_IntPtr(base.SuperHandle, selConvertTimeFromLayer_Handle, timeInterval, layer?.Handle ?? IntPtr.Zero);
		}

		[Export("convertTime:toLayer:")]
		public virtual double ConvertTimeToLayer(double timeInterval, CALayer layer)
		{
			if (IsDirectBinding)
			{
				return Messaging.Double_objc_msgSend_Double_IntPtr(base.Handle, selConvertTimeToLayer_Handle, timeInterval, layer?.Handle ?? IntPtr.Zero);
			}
			return Messaging.Double_objc_msgSendSuper_Double_IntPtr(base.SuperHandle, selConvertTimeToLayer_Handle, timeInterval, layer?.Handle ?? IntPtr.Zero);
		}

		[Export("hitTest:")]
		public virtual CALayer HitTest(CGPoint p)
		{
			if (IsDirectBinding)
			{
				return (CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_CGPoint(base.Handle, selHitTest_Handle, p));
			}
			return (CALayer)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper_CGPoint(base.SuperHandle, selHitTest_Handle, p));
		}

		[Export("containsPoint:")]
		public virtual bool Contains(CGPoint p)
		{
			if (IsDirectBinding)
			{
				return Messaging.bool_objc_msgSend_CGPoint(base.Handle, selContainsPoint_Handle, p);
			}
			return Messaging.bool_objc_msgSendSuper_CGPoint(base.SuperHandle, selContainsPoint_Handle, p);
		}

		[Export("display")]
		public virtual void Display()
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend(base.Handle, selDisplayHandle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper(base.SuperHandle, selDisplayHandle);
			}
		}

		[Export("setNeedsDisplay")]
		public virtual void SetNeedsDisplay()
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend(base.Handle, selSetNeedsDisplayHandle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper(base.SuperHandle, selSetNeedsDisplayHandle);
			}
		}

		[Export("setNeedsDisplayInRect:")]
		public virtual void SetNeedsDisplayInRect(CGRect r)
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_CGRect(base.Handle, selSetNeedsDisplayInRect_Handle, r);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_CGRect(base.SuperHandle, selSetNeedsDisplayInRect_Handle, r);
			}
		}

		[Export("displayIfNeeded")]
		public virtual void DisplayIfNeeded()
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend(base.Handle, selDisplayIfNeededHandle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper(base.SuperHandle, selDisplayIfNeededHandle);
			}
		}

		[Export("drawInContext:")]
		public virtual void DrawInContext(CGContext ctx)
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr(base.Handle, selDrawInContext_Handle, ctx.Handle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selDrawInContext_Handle, ctx.Handle);
			}
		}

		[Export("renderInContext:")]
		public virtual void RenderInContext(CGContext ctx)
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr(base.Handle, selRenderInContext_Handle, ctx.Handle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selRenderInContext_Handle, ctx.Handle);
			}
		}

		[Export("preferredFrameSize")]
		public virtual CGSize PreferredFrameSize()
		{
			if (IsDirectBinding)
			{
				return Messaging.CGSize_objc_msgSend(base.Handle, selPreferredFrameSizeHandle);
			}
			return Messaging.CGSize_objc_msgSendSuper(base.SuperHandle, selPreferredFrameSizeHandle);
		}

		[Export("setNeedsLayout")]
		public virtual void SetNeedsLayout()
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend(base.Handle, selSetNeedsLayoutHandle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper(base.SuperHandle, selSetNeedsLayoutHandle);
			}
		}

		[Export("needsLayout")]
		public virtual bool NeedsLayout()
		{
			if (IsDirectBinding)
			{
				return Messaging.bool_objc_msgSend(base.Handle, selNeedsLayoutHandle);
			}
			return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selNeedsLayoutHandle);
		}

		[Export("layoutIfNeeded")]
		public virtual void LayoutIfNeeded()
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend(base.Handle, selLayoutIfNeededHandle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper(base.SuperHandle, selLayoutIfNeededHandle);
			}
		}

		[Export("layoutSublayers")]
		public virtual void LayoutSublayers()
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend(base.Handle, selLayoutSublayersHandle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper(base.SuperHandle, selLayoutSublayersHandle);
			}
		}

		[Export("defaultActionForKey:")]
		public static NSObject DefaultActionForKey(string eventKey)
		{
			if (eventKey == null)
			{
				throw new ArgumentNullException("eventKey");
			}
			IntPtr intPtr = NSString.CreateNative(eventKey);
			NSObject nSObject = Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(class_ptr, selDefaultActionForKey_Handle, intPtr));
			NSString.ReleaseNative(intPtr);
			return nSObject;
		}

		[Export("actionForKey:")]
		public virtual NSObject ActionForKey(string eventKey)
		{
			if (eventKey == null)
			{
				throw new ArgumentNullException("eventKey");
			}
			IntPtr intPtr = NSString.CreateNative(eventKey);
			NSObject result = (!IsDirectBinding) ? Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, selActionForKey_Handle, intPtr)) : Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, selActionForKey_Handle, intPtr));
			NSString.ReleaseNative(intPtr);
			return result;
		}

		[Export("addAnimation:forKey:")]
		public virtual void AddAnimation(CAAnimation animation, string key)
		{
			if (animation == null)
			{
				throw new ArgumentNullException("animation");
			}
			IntPtr intPtr = NSString.CreateNative(key);
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr_IntPtr(base.Handle, selAddAnimationForKey_Handle, animation.Handle, intPtr);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selAddAnimationForKey_Handle, animation.Handle, intPtr);
			}
			NSString.ReleaseNative(intPtr);
		}

		[Export("removeAllAnimations")]
		public virtual void RemoveAllAnimations()
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend(base.Handle, selRemoveAllAnimationsHandle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper(base.SuperHandle, selRemoveAllAnimationsHandle);
			}
		}

		[Export("removeAnimationForKey:")]
		public virtual void RemoveAnimation(string key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			IntPtr intPtr = NSString.CreateNative(key);
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr(base.Handle, selRemoveAnimationForKey_Handle, intPtr);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selRemoveAnimationForKey_Handle, intPtr);
			}
			NSString.ReleaseNative(intPtr);
		}

		[Export("animationForKey:")]
		public virtual CAAnimation AnimationForKey(string key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			IntPtr intPtr = NSString.CreateNative(key);
			CAAnimation result = (!IsDirectBinding) ? ((CAAnimation)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, selAnimationForKey_Handle, intPtr))) : ((CAAnimation)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, selAnimationForKey_Handle, intPtr)));
			NSString.ReleaseNative(intPtr);
			return result;
		}

		[Export("scrollPoint:")]
		public virtual void ScrollPoint(CGPoint p)
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_CGPoint(base.Handle, selScrollPoint_Handle, p);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_CGPoint(base.SuperHandle, selScrollPoint_Handle, p);
			}
		}

		[Export("scrollRectToVisible:")]
		public virtual void ScrollRectToVisible(CGRect r)
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_CGRect(base.Handle, selScrollRectToVisible_Handle, r);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_CGRect(base.SuperHandle, selScrollRectToVisible_Handle, r);
			}
		}

		[Export("resizeSublayersWithOldSize:")]
		public virtual void ResizeSublayers(CGSize oldSize)
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_CGSize(base.Handle, selResizeSublayersWithOldSize_Handle, oldSize);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_CGSize(base.SuperHandle, selResizeSublayersWithOldSize_Handle, oldSize);
			}
		}

		[Export("resizeWithOldSuperlayerSize:")]
		public virtual void Resize(CGSize oldSuperlayerSize)
		{
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_CGSize(base.Handle, selResizeWithOldSuperlayerSize_Handle, oldSuperlayerSize);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_CGSize(base.SuperHandle, selResizeWithOldSuperlayerSize_Handle, oldSuperlayerSize);
			}
		}

		[Export("addConstraint:")]
		public virtual void AddConstraint(CAConstraint c)
		{
			if (c == null)
			{
				throw new ArgumentNullException("c");
			}
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_IntPtr(base.Handle, selAddConstraint_Handle, c.Handle);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selAddConstraint_Handle, c.Handle);
			}
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			if (base.Handle == IntPtr.Zero)
			{
				__mt_PresentationLayer_var = null;
				__mt_ModelLayer_var = null;
				__mt_SuperLayer_var = null;
				__mt_Sublayers_var = null;
				__mt_Mask_var = null;
				__mt_LayoutManager_var = null;
				__mt_Actions_var = null;
				__mt_WeakDelegate_var = null;
				__mt_Constraints_var = null;
				__mt_Filters_var = null;
			}
		}
	}
}