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

namespace CPF.Mac.AppKit
{
	[DebuggerTypeProxy(typeof(NSEventDebuggerProxy))]
	[Register("NSEvent", true)]
	public class NSEvent : NSObject
	{
		private class NSEventDebuggerProxy
		{
			private NSEvent target;

			private const int TabletPointEventSubtype = 1;

			private const int TabletProximityEventSubtype = 2;

			internal NSGraphicsContext Context => target.Context;

			public CGPoint LocationInWindow => target.LocationInWindow;

			public NSEventModifierMask ModifierFlags => target.ModifierFlags;

			public double Timestamp => target.Timestamp;

			public NSEventType Type => target.Type;

			public NSWindow Window => target.Window;

			public long WindowNumber => target.WindowNumber;

			public IntPtr CGEvent => target.CGEvent;

			public string Characters
			{
				get
				{
					CheckKeyEvent();
					return target.Characters;
				}
			}

			public string CharactersIgnoringModifiers
			{
				get
				{
					CheckKeyEvent();
					return target.CharactersIgnoringModifiers;
				}
			}

			public bool IsARepeat
			{
				get
				{
					CheckKeyEvent();
					return target.IsARepeat;
				}
			}

			public ushort KeyCode
			{
				get
				{
					CheckKeyEvent();
					return target.KeyCode;
				}
			}

			public long AbsoluteX
			{
				get
				{
					CheckTabletPointingEvent();
					return target.AbsoluteX;
				}
			}

			public long AbsoluteY
			{
				get
				{
					CheckTabletPointingEvent();
					return target.AbsoluteY;
				}
			}

			public long AbsoluteZ
			{
				get
				{
					CheckTabletPointingEvent();
					return target.AbsoluteZ;
				}
			}

			public ulong ButtonMask
			{
				get
				{
					CheckTabletPointingEvent();
					return target.ButtonMask;
				}
			}

			public double Rotation
			{
				get
				{
					CheckTabletPointingEvent();
					return target.Rotation;
				}
			}

			public double TangentialPressure
			{
				get
				{
					CheckTabletPointingEvent();
					return target.TangentialPressure;
				}
			}

			public CGPoint Tilt
			{
				get
				{
					CheckTabletPointingEvent();
					return target.Tilt;
				}
			}

			public NSObject VendorDefined
			{
				get
				{
					CheckTabletPointingEvent();
					return target.VendorDefined;
				}
			}

			public long ButtonNumber
			{
				get
				{
					CheckMouseEvent();
					return target.ButtonNumber;
				}
			}

			public long ClickCount
			{
				get
				{
					CheckMouseEvent();
					return target.ClickCount;
				}
			}

			public double Pressure
			{
				get
				{
					CheckMouseEvent();
					return target.Pressure;
				}
			}

			internal long EventNumber
			{
				get
				{
					CheckMouseTrackingEvent();
					return target.EventNumber;
				}
			}

			internal long TrackingNumber
			{
				get
				{
					CheckMouseTrackingEvent();
					return target.TrackingNumber;
				}
			}

			internal NSTrackingArea TrackingArea
			{
				get
				{
					CheckMouseTrackingEvent();
					return target.TrackingArea;
				}
			}

			internal IntPtr UserData
			{
				get
				{
					CheckMouseTrackingEvent();
					return target.UserData;
				}
			}

			public short Subtype
			{
				get
				{
					CheckCustomEvent();
					return target.Subtype;
				}
			}

			public long Data1
			{
				get
				{
					CheckCustomEvent();
					return target.Data1;
				}
			}

			public long Data2
			{
				get
				{
					CheckCustomEvent();
					return target.Data1;
				}
			}

			public double DeltaX
			{
				get
				{
					CheckScrollWheelEvent();
					return target.Data1;
				}
			}

			public double DeltaY
			{
				get
				{
					CheckScrollWheelEvent();
					return target.Data1;
				}
			}

			public double DeltaZ
			{
				get
				{
					CheckScrollWheelEvent();
					return target.Data1;
				}
			}

			public ulong CapabilityMask
			{
				get
				{
					CheckTabletProximityEvent();
					return target.CapabilityMask;
				}
			}

			public ulong DeviceID
			{
				get
				{
					CheckTabletProximityEvent();
					return target.DeviceID;
				}
			}

			public bool IsEnteringProximity
			{
				get
				{
					CheckTabletProximityEvent();
					return target.IsEnteringProximity;
				}
			}

			public ulong PointingDeviceSerialNumber
			{
				get
				{
					CheckTabletProximityEvent();
					return target.PointingDeviceSerialNumber;
				}
			}

			public ulong PointingDeviceID
			{
				get
				{
					CheckTabletProximityEvent();
					return target.PointingDeviceID();
				}
			}

			public NSPointingDeviceType PointingDeviceType
			{
				get
				{
					CheckTabletProximityEvent();
					return target.PointingDeviceType;
				}
			}

			public ulong SystemTabletID
			{
				get
				{
					CheckTabletProximityEvent();
					return target.SystemTabletID;
				}
			}

			public ulong TabletID
			{
				get
				{
					CheckTabletProximityEvent();
					return target.TabletID;
				}
			}

			public long UniqueID
			{
				get
				{
					CheckTabletProximityEvent();
					return target.UniqueID;
				}
			}

			public ulong VendorID
			{
				get
				{
					CheckTabletProximityEvent();
					return target.VendorID;
				}
			}

			public ulong VendorPointingDeviceType
			{
				get
				{
					CheckTabletProximityEvent();
					return target.VendorPointingDeviceType;
				}
			}

			internal double Magnification
			{
				get
				{
					CheckTouchOrGestureEvent();
					return target.Magnification;
				}
			}

			public bool HasPreciseScrollingDeltas
			{
				get
				{
					CheckScrollWheelOrFlickEvent();
					return target.HasPreciseScrollingDeltas;
				}
			}

			public double ScrollingDeltaX
			{
				get
				{
					CheckScrollWheelOrFlickEvent();
					return target.ScrollingDeltaX;
				}
			}

			public double ScrollingDeltaY
			{
				get
				{
					CheckScrollWheelOrFlickEvent();
					return target.ScrollingDeltaY;
				}
			}

			public NSEventPhase MomentumPhase
			{
				get
				{
					CheckScrollWheelOrFlickEvent();
					return target.MomentumPhase;
				}
			}

			public NSEventPhase Phase
			{
				get
				{
					CheckScrollWheelOrFlickEvent();
					return target.Phase;
				}
			}

			public bool IsDirectionInvertedFromDevice
			{
				get
				{
					CheckScrollWheelOrFlickEvent();
					return target.IsDirectionInvertedFromDevice;
				}
			}

			public NSEventDebuggerProxy(NSEvent target)
			{
				this.target = target;
			}

			private bool IsKeyEvent()
			{
				NSEventType type = target.Type;
				if (type - 10 <= NSEventType.LeftMouseDown)
				{
					return true;
				}
				return false;
			}

			private void CheckKeyEvent()
			{
				if (IsKeyEvent())
				{
					return;
				}
				throw new InvalidOperationException("Not a key event.");
			}

			private bool IsMouseEvent()
			{
				NSEventType type = target.Type;
				if (type - 1 <= NSEventType.MouseEntered || type - 25 <= NSEventType.LeftMouseUp)
				{
					return true;
				}
				return false;
			}

			private bool IsTabletPointingEvent()
			{
				if (IsMouseEvent())
				{
					return target.Subtype == 1;
				}
				return target.Type == NSEventType.TabletPoint;
			}

			private void CheckTabletPointingEvent()
			{
				if (IsTabletPointingEvent())
				{
					return;
				}
				throw new InvalidOperationException("Not a tablet pointing event.");
			}

			private void CheckMouseEvent()
			{
				if (IsMouseEvent())
				{
					return;
				}
				throw new InvalidOperationException("Not a mouse event.");
			}

			private bool IsMouseTrackingEvent()
			{
				return false;
			}

			private void CheckMouseTrackingEvent()
			{
				if (IsMouseTrackingEvent())
				{
					return;
				}
				throw new InvalidOperationException("Not a mouse tracking event.");
			}

			private bool IsCustomEvent()
			{
				NSEventType type = target.Type;
				if (type - 13 <= NSEventType.RightMouseDown)
				{
					return true;
				}
				return false;
			}

			private void CheckCustomEvent()
			{
				if (IsCustomEvent())
				{
					return;
				}
				throw new InvalidOperationException("Not a custom event.");
			}

			private bool IsScrollWheelEvent()
			{
				NSEventType type = target.Type;
				if (type == NSEventType.ScrollWheel)
				{
					return true;
				}
				return false;
			}

			private void CheckScrollWheelEvent()
			{
				if (IsScrollWheelEvent())
				{
					return;
				}
				throw new InvalidOperationException("Not a scroll wheel event.");
			}

			private bool IsTabletProximityEvent()
			{
				if (IsMouseEvent())
				{
					return target.Subtype == 2;
				}
				return target.Type == NSEventType.TabletProximity;
			}

			private void CheckTabletProximityEvent()
			{
				if (IsTabletProximityEvent())
				{
					return;
				}
				throw new InvalidOperationException("Not a tablet proximity event.");
			}

			private bool IsTouchOrGestureEvent()
			{
				return false;
			}

			private void CheckTouchOrGestureEvent()
			{
				if (IsTouchOrGestureEvent())
				{
					return;
				}
				throw new InvalidOperationException("Not a touch or gesture event.");
			}

			private bool IsScrollWheelOrFlickEvent()
			{
				if (IsScrollWheelEvent())
				{
					return true;
				}
				return false;
			}

			private void CheckScrollWheelOrFlickEvent()
			{
				if (IsScrollWheelOrFlickEvent())
				{
					return;
				}
				throw new InvalidOperationException("Not a scroll wheel or flick event.");
			}
		}

		private static readonly IntPtr selTypeHandle = Selector.GetHandle("type");

		private static readonly IntPtr selModifierFlagsHandle = Selector.GetHandle("modifierFlags");

		private static readonly IntPtr selTimestampHandle = Selector.GetHandle("timestamp");

		private static readonly IntPtr selWindowHandle = Selector.GetHandle("window");

		private static readonly IntPtr selWindowNumberHandle = Selector.GetHandle("windowNumber");

		private static readonly IntPtr selContextHandle = Selector.GetHandle("context");

		private static readonly IntPtr selClickCountHandle = Selector.GetHandle("clickCount");

		private static readonly IntPtr selButtonNumberHandle = Selector.GetHandle("buttonNumber");

		private static readonly IntPtr selEventNumberHandle = Selector.GetHandle("eventNumber");

		private static readonly IntPtr selPressureHandle = Selector.GetHandle("pressure");

		private static readonly IntPtr selLocationInWindowHandle = Selector.GetHandle("locationInWindow");

		private static readonly IntPtr selDeltaXHandle = Selector.GetHandle("deltaX");

		private static readonly IntPtr selDeltaYHandle = Selector.GetHandle("deltaY");

		private static readonly IntPtr selDeltaZHandle = Selector.GetHandle("deltaZ");

		private static readonly IntPtr selCharactersHandle = Selector.GetHandle("characters");

		private static readonly IntPtr selCharactersIgnoringModifiersHandle = Selector.GetHandle("charactersIgnoringModifiers");

		private static readonly IntPtr selIsARepeatHandle = Selector.GetHandle("isARepeat");

		private static readonly IntPtr selKeyCodeHandle = Selector.GetHandle("keyCode");

		private static readonly IntPtr selTrackingNumberHandle = Selector.GetHandle("trackingNumber");

		private static readonly IntPtr selUserDataHandle = Selector.GetHandle("userData");

		private static readonly IntPtr selTrackingAreaHandle = Selector.GetHandle("trackingArea");

		private static readonly IntPtr selSubtypeHandle = Selector.GetHandle("subtype");

		private static readonly IntPtr selData1Handle = Selector.GetHandle("data1");

		private static readonly IntPtr selData2Handle = Selector.GetHandle("data2");

		private static readonly IntPtr selCGEventHandle = Selector.GetHandle("CGEvent");

		private static readonly IntPtr selMagnificationHandle = Selector.GetHandle("magnification");

		private static readonly IntPtr selDeviceIDHandle = Selector.GetHandle("deviceID");

		private static readonly IntPtr selRotationHandle = Selector.GetHandle("rotation");

		private static readonly IntPtr selAbsoluteXHandle = Selector.GetHandle("absoluteX");

		private static readonly IntPtr selAbsoluteYHandle = Selector.GetHandle("absoluteY");

		private static readonly IntPtr selAbsoluteZHandle = Selector.GetHandle("absoluteZ");

		private static readonly IntPtr selButtonMaskHandle = Selector.GetHandle("buttonMask");

		private static readonly IntPtr selTiltHandle = Selector.GetHandle("tilt");

		private static readonly IntPtr selTangentialPressureHandle = Selector.GetHandle("tangentialPressure");

		private static readonly IntPtr selVendorDefinedHandle = Selector.GetHandle("vendorDefined");

		private static readonly IntPtr selVendorIDHandle = Selector.GetHandle("vendorID");

		private static readonly IntPtr selTabletIDHandle = Selector.GetHandle("tabletID");

		private static readonly IntPtr selSystemTabletIDHandle = Selector.GetHandle("systemTabletID");

		private static readonly IntPtr selVendorPointingDeviceTypeHandle = Selector.GetHandle("vendorPointingDeviceType");

		private static readonly IntPtr selPointingDeviceSerialNumberHandle = Selector.GetHandle("pointingDeviceSerialNumber");

		private static readonly IntPtr selUniqueIDHandle = Selector.GetHandle("uniqueID");

		private static readonly IntPtr selCapabilityMaskHandle = Selector.GetHandle("capabilityMask");

		private static readonly IntPtr selPointingDeviceTypeHandle = Selector.GetHandle("pointingDeviceType");

		private static readonly IntPtr selIsEnteringProximityHandle = Selector.GetHandle("isEnteringProximity");

		private static readonly IntPtr selMouseLocationHandle = Selector.GetHandle("mouseLocation");

		private static readonly IntPtr selPressedMouseButtonsHandle = Selector.GetHandle("pressedMouseButtons");

		private static readonly IntPtr selDoubleClickIntervalHandle = Selector.GetHandle("doubleClickInterval");

		private static readonly IntPtr selKeyRepeatDelayHandle = Selector.GetHandle("keyRepeatDelay");

		private static readonly IntPtr selKeyRepeatIntervalHandle = Selector.GetHandle("keyRepeatInterval");

		private static readonly IntPtr selIsMouseCoalescingEnabledHandle = Selector.GetHandle("isMouseCoalescingEnabled");

		private static readonly IntPtr selSetMouseCoalescingEnabled_Handle = Selector.GetHandle("setMouseCoalescingEnabled:");

		private static readonly IntPtr selHasPreciseScrollingDeltasHandle = Selector.GetHandle("hasPreciseScrollingDeltas");

		private static readonly IntPtr selScrollingDeltaXHandle = Selector.GetHandle("scrollingDeltaX");

		private static readonly IntPtr selScrollingDeltaYHandle = Selector.GetHandle("scrollingDeltaY");

		private static readonly IntPtr selMomentumPhaseHandle = Selector.GetHandle("momentumPhase");

		private static readonly IntPtr selIsDirectionInvertedFromDeviceHandle = Selector.GetHandle("isDirectionInvertedFromDevice");

		private static readonly IntPtr selPhaseHandle = Selector.GetHandle("phase");

		private static readonly IntPtr selIsSwipeTrackingFromScrollEventsEnabledHandle = Selector.GetHandle("isSwipeTrackingFromScrollEventsEnabled");

		private static readonly IntPtr selEventWithEventRef_Handle = Selector.GetHandle("eventWithEventRef:");

		private static readonly IntPtr selEventWithCGEvent_Handle = Selector.GetHandle("eventWithCGEvent:");

		private static readonly IntPtr selPointingDeviceIDHandle = Selector.GetHandle("pointingDeviceID");

		private static readonly IntPtr selTouchesMatchingPhaseInView_Handle = Selector.GetHandle("touchesMatchingPhase:inView:");

		private static readonly IntPtr selStartPeriodicEventsAfterDelayWithPeriod_Handle = Selector.GetHandle("startPeriodicEventsAfterDelay:withPeriod:");

		private static readonly IntPtr selStopPeriodicEventsHandle = Selector.GetHandle("stopPeriodicEvents");

		private static readonly IntPtr selMouseEventWithTypeLocationModifierFlagsTimestampWindowNumberContextEventNumberClickCountPressure_Handle = Selector.GetHandle("mouseEventWithType:location:modifierFlags:timestamp:windowNumber:context:eventNumber:clickCount:pressure:");

		private static readonly IntPtr selKeyEventWithTypeLocationModifierFlagsTimestampWindowNumberContextCharactersCharactersIgnoringModifiersIsARepeatKeyCode_Handle = Selector.GetHandle("keyEventWithType:location:modifierFlags:timestamp:windowNumber:context:characters:charactersIgnoringModifiers:isARepeat:keyCode:");

		private static readonly IntPtr selEnterExitEventWithTypeLocationModifierFlagsTimestampWindowNumberContextEventNumberTrackingNumberUserData_Handle = Selector.GetHandle("enterExitEventWithType:location:modifierFlags:timestamp:windowNumber:context:eventNumber:trackingNumber:userData:");

		private static readonly IntPtr selOtherEventWithTypeLocationModifierFlagsTimestampWindowNumberContextSubtypeData1Data2_Handle = Selector.GetHandle("otherEventWithType:location:modifierFlags:timestamp:windowNumber:context:subtype:data1:data2:");

		private static readonly IntPtr selAddGlobalMonitorForEventsMatchingMaskHandler_Handle = Selector.GetHandle("addGlobalMonitorForEventsMatchingMask:handler:");

		private static readonly IntPtr selAddLocalMonitorForEventsMatchingMaskHandler_Handle = Selector.GetHandle("addLocalMonitorForEventsMatchingMask:handler:");

		private static readonly IntPtr selRemoveMonitor_Handle = Selector.GetHandle("removeMonitor:");

		private static readonly IntPtr selTrackSwipeEventWithOptionsDampenAmountThresholdMinMaxUsingHandler_Handle = Selector.GetHandle("trackSwipeEventWithOptions:dampenAmountThresholdMin:max:usingHandler:");

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

		private object __mt_Window_var;

		private object __mt_Context_var;

		private object __mt_TrackingArea_var;

		private object __mt_VendorDefined_var;

		public override IntPtr ClassHandle => class_ptr;

		public virtual NSEventType Type
		{
			[Export("type")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return (NSEventType)Messaging.UInt64_objc_msgSend(base.Handle, selTypeHandle);
				}
				return (NSEventType)Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selTypeHandle);
			}
		}

		public virtual NSEventModifierMask ModifierFlags
		{
			[Export("modifierFlags")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return (NSEventModifierMask)Messaging.UInt64_objc_msgSend(base.Handle, selModifierFlagsHandle);
				}
				return (NSEventModifierMask)Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selModifierFlagsHandle);
			}
		}

		public virtual double Timestamp
		{
			[Export("timestamp")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selTimestampHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selTimestampHandle);
			}
		}

		public virtual NSWindow Window
		{
			[Export("window")]
			get
			{
				NSApplication.EnsureUIThread();
				return (NSWindow)(__mt_Window_var = ((!IsDirectBinding) ? ((NSWindow)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selWindowHandle))) : ((NSWindow)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selWindowHandle)))));
			}
		}

		public virtual long WindowNumber
		{
			[Export("windowNumber")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selWindowNumberHandle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selWindowNumberHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual NSGraphicsContext Context
		{
			[Export("context")]
			get
			{
				NSApplication.EnsureUIThread();
				return (NSGraphicsContext)(__mt_Context_var = ((!IsDirectBinding) ? ((NSGraphicsContext)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selContextHandle))) : ((NSGraphicsContext)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selContextHandle)))));
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long ClickCount
		{
			[Export("clickCount")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selClickCountHandle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selClickCountHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long ButtonNumber
		{
			[Export("buttonNumber")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selButtonNumberHandle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selButtonNumberHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long EventNumber
		{
			[Export("eventNumber")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selEventNumberHandle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selEventNumberHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual double Pressure
		{
			[Export("pressure")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selPressureHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selPressureHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual CGPoint LocationInWindow
		{
			[Export("locationInWindow")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.CGPoint_objc_msgSend(base.Handle, selLocationInWindowHandle);
				}
				return Messaging.CGPoint_objc_msgSendSuper(base.SuperHandle, selLocationInWindowHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual double DeltaX
		{
			[Export("deltaX")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selDeltaXHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selDeltaXHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual double DeltaY
		{
			[Export("deltaY")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selDeltaYHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selDeltaYHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual double DeltaZ
		{
			[Export("deltaZ")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selDeltaZHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selDeltaZHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual string Characters
		{
			[Export("characters")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selCharactersHandle));
				}
				return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selCharactersHandle));
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual string CharactersIgnoringModifiers
		{
			[Export("charactersIgnoringModifiers")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selCharactersIgnoringModifiersHandle));
				}
				return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selCharactersIgnoringModifiersHandle));
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual bool IsARepeat
		{
			[Export("isARepeat")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selIsARepeatHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsARepeatHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual ushort KeyCode
		{
			[Export("keyCode")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.UInt16_objc_msgSend(base.Handle, selKeyCodeHandle);
				}
				return Messaging.UInt16_objc_msgSendSuper(base.SuperHandle, selKeyCodeHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long TrackingNumber
		{
			[Export("trackingNumber")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selTrackingNumberHandle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selTrackingNumberHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual IntPtr UserData
		{
			[Export("userData")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.IntPtr_objc_msgSend(base.Handle, selUserDataHandle);
				}
				return Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selUserDataHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual NSTrackingArea TrackingArea
		{
			[Export("trackingArea")]
			get
			{
				NSApplication.EnsureUIThread();
				return (NSTrackingArea)(__mt_TrackingArea_var = ((!IsDirectBinding) ? ((NSTrackingArea)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selTrackingAreaHandle))) : ((NSTrackingArea)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selTrackingAreaHandle)))));
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual short Subtype
		{
			[Export("subtype")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.short_objc_msgSend(base.Handle, selSubtypeHandle);
				}
				return Messaging.short_objc_msgSendSuper(base.SuperHandle, selSubtypeHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long Data1
		{
			[Export("data1")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selData1Handle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selData1Handle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long Data2
		{
			[Export("data2")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selData2Handle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selData2Handle);
			}
		}

		public virtual IntPtr CGEvent
		{
			[Export("CGEvent")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.IntPtr_objc_msgSend(base.Handle, selCGEventHandle);
				}
				return Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selCGEventHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual double Magnification
		{
			[Export("magnification")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selMagnificationHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selMagnificationHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual ulong DeviceID
		{
			[Export("deviceID")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.UInt64_objc_msgSend(base.Handle, selDeviceIDHandle);
				}
				return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selDeviceIDHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual double Rotation
		{
			[Export("rotation")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selRotationHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selRotationHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long AbsoluteX
		{
			[Export("absoluteX")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selAbsoluteXHandle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selAbsoluteXHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long AbsoluteY
		{
			[Export("absoluteY")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selAbsoluteYHandle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selAbsoluteYHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long AbsoluteZ
		{
			[Export("absoluteZ")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selAbsoluteZHandle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selAbsoluteZHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual ulong ButtonMask
		{
			[Export("buttonMask")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.UInt64_objc_msgSend(base.Handle, selButtonMaskHandle);
				}
				return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selButtonMaskHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual CGPoint Tilt
		{
			[Export("tilt")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.CGPoint_objc_msgSend(base.Handle, selTiltHandle);
				}
				return Messaging.CGPoint_objc_msgSendSuper(base.SuperHandle, selTiltHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual double TangentialPressure
		{
			[Export("tangentialPressure")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selTangentialPressureHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selTangentialPressureHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual NSObject VendorDefined
		{
			[Export("vendorDefined")]
			get
			{
				NSApplication.EnsureUIThread();
				return (NSObject)(__mt_VendorDefined_var = ((!IsDirectBinding) ? Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selVendorDefinedHandle)) : Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selVendorDefinedHandle))));
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual ulong VendorID
		{
			[Export("vendorID")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.UInt64_objc_msgSend(base.Handle, selVendorIDHandle);
				}
				return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selVendorIDHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual ulong TabletID
		{
			[Export("tabletID")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.UInt64_objc_msgSend(base.Handle, selTabletIDHandle);
				}
				return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selTabletIDHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual ulong SystemTabletID
		{
			[Export("systemTabletID")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.UInt64_objc_msgSend(base.Handle, selSystemTabletIDHandle);
				}
				return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selSystemTabletIDHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual ulong VendorPointingDeviceType
		{
			[Export("vendorPointingDeviceType")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.UInt64_objc_msgSend(base.Handle, selVendorPointingDeviceTypeHandle);
				}
				return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selVendorPointingDeviceTypeHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual ulong PointingDeviceSerialNumber
		{
			[Export("pointingDeviceSerialNumber")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.UInt64_objc_msgSend(base.Handle, selPointingDeviceSerialNumberHandle);
				}
				return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selPointingDeviceSerialNumberHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual long UniqueID
		{
			[Export("uniqueID")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Int64_objc_msgSend(base.Handle, selUniqueIDHandle);
				}
				return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selUniqueIDHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual ulong CapabilityMask
		{
			[Export("capabilityMask")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.UInt64_objc_msgSend(base.Handle, selCapabilityMaskHandle);
				}
				return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selCapabilityMaskHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual NSPointingDeviceType PointingDeviceType
		{
			[Export("pointingDeviceType")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return (NSPointingDeviceType)Messaging.UInt64_objc_msgSend(base.Handle, selPointingDeviceTypeHandle);
				}
				return (NSPointingDeviceType)Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selPointingDeviceTypeHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual bool IsEnteringProximity
		{
			[Export("isEnteringProximity")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selIsEnteringProximityHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsEnteringProximityHandle);
			}
		}

		public static CGPoint CurrentMouseLocation
		{
			[Export("mouseLocation")]
			get
			{
				NSApplication.EnsureUIThread();
				return Messaging.CGPoint_objc_msgSend(class_ptr, selMouseLocationHandle);
			}
		}

		public static NSEventModifierMask CurrentModifierFlags
		{
			[Export("modifierFlags")]
			get
			{
				NSApplication.EnsureUIThread();
				return (NSEventModifierMask)Messaging.UInt64_objc_msgSend(class_ptr, selModifierFlagsHandle);
			}
		}

		public static ulong CurrentPressedMouseButtons
		{
			[Export("pressedMouseButtons")]
			get
			{
				NSApplication.EnsureUIThread();
				return Messaging.UInt64_objc_msgSend(class_ptr, selPressedMouseButtonsHandle);
			}
		}

		public static double DoubleClickInterval
		{
			[Export("doubleClickInterval")]
			get
			{
				NSApplication.EnsureUIThread();
				return Messaging.Double_objc_msgSend(class_ptr, selDoubleClickIntervalHandle);
			}
		}

		public static double KeyRepeatDelay
		{
			[Export("keyRepeatDelay")]
			get
			{
				NSApplication.EnsureUIThread();
				return Messaging.Double_objc_msgSend(class_ptr, selKeyRepeatDelayHandle);
			}
		}

		public static double KeyRepeatInterval
		{
			[Export("keyRepeatInterval")]
			get
			{
				NSApplication.EnsureUIThread();
				return Messaging.Double_objc_msgSend(class_ptr, selKeyRepeatIntervalHandle);
			}
		}

		public static bool MouseCoalescingEnabled
		{
			[Export("isMouseCoalescingEnabled")]
			get
			{
				NSApplication.EnsureUIThread();
				return Messaging.bool_objc_msgSend(class_ptr, selIsMouseCoalescingEnabledHandle);
			}
			[Export("setMouseCoalescingEnabled:")]
			set
			{
				NSApplication.EnsureUIThread();
				Messaging.void_objc_msgSend_bool(class_ptr, selSetMouseCoalescingEnabled_Handle, value);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual bool HasPreciseScrollingDeltas
		{
			[Export("hasPreciseScrollingDeltas")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selHasPreciseScrollingDeltasHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selHasPreciseScrollingDeltasHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual double ScrollingDeltaX
		{
			[Export("scrollingDeltaX")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selScrollingDeltaXHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selScrollingDeltaXHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual double ScrollingDeltaY
		{
			[Export("scrollingDeltaY")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.Double_objc_msgSend(base.Handle, selScrollingDeltaYHandle);
				}
				return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selScrollingDeltaYHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual NSEventPhase MomentumPhase
		{
			[Export("momentumPhase")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return (NSEventPhase)Messaging.UInt64_objc_msgSend(base.Handle, selMomentumPhaseHandle);
				}
				return (NSEventPhase)Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selMomentumPhaseHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual bool IsDirectionInvertedFromDevice
		{
			[Export("isDirectionInvertedFromDevice")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return Messaging.bool_objc_msgSend(base.Handle, selIsDirectionInvertedFromDeviceHandle);
				}
				return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsDirectionInvertedFromDeviceHandle);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual NSEventPhase Phase
		{
			[Export("phase")]
			get
			{
				NSApplication.EnsureUIThread();
				if (IsDirectBinding)
				{
					return (NSEventPhase)Messaging.UInt64_objc_msgSend(base.Handle, selPhaseHandle);
				}
				return (NSEventPhase)Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selPhaseHandle);
			}
		}

		public static bool IsSwipeTrackingFromScrollEventsEnabled
		{
			[Export("isSwipeTrackingFromScrollEventsEnabled")]
			get
			{
				NSApplication.EnsureUIThread();
				return Messaging.bool_objc_msgSend(class_ptr, selIsSwipeTrackingFromScrollEventsEnabledHandle);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		[Export("init")]
		public NSEvent()
			: 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 NSEvent(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 NSEvent(NSObjectFlag t)
			: base(t)
		{
		}

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

		[Export("eventWithEventRef:")]
		public static NSEvent EventWithEventRef(IntPtr cgEventRef)
		{
			NSApplication.EnsureUIThread();
			return (NSEvent)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(class_ptr, selEventWithEventRef_Handle, cgEventRef));
		}

		[Export("eventWithCGEvent:")]
		public static NSEvent EventWithCGEvent(IntPtr cgEventPtr)
		{
			NSApplication.EnsureUIThread();
			return (NSEvent)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(class_ptr, selEventWithCGEvent_Handle, cgEventPtr));
		}

		[Export("pointingDeviceID")]
		public virtual ulong PointingDeviceID()
		{
			NSApplication.EnsureUIThread();
			if (IsDirectBinding)
			{
				return Messaging.UInt64_objc_msgSend(base.Handle, selPointingDeviceIDHandle);
			}
			return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selPointingDeviceIDHandle);
		}

		[Export("touchesMatchingPhase:inView:")]
		public virtual NSSet TouchesMatchingPhase(NSTouchPhase phase, NSView view)
		{
			NSApplication.EnsureUIThread();
			if (view == null)
			{
				throw new ArgumentNullException("view");
			}
			if (IsDirectBinding)
			{
				return (NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_UInt64_IntPtr(base.Handle, selTouchesMatchingPhaseInView_Handle, (ulong)phase, view.Handle));
			}
			return (NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper_UInt64_IntPtr(base.SuperHandle, selTouchesMatchingPhaseInView_Handle, (ulong)phase, view.Handle));
		}

		[Export("startPeriodicEventsAfterDelay:withPeriod:")]
		public static void StartPeriodicEventsAfterDelay(double delay, double period)
		{
			NSApplication.EnsureUIThread();
			Messaging.void_objc_msgSend_Double_Double(class_ptr, selStartPeriodicEventsAfterDelayWithPeriod_Handle, delay, period);
		}

		[Export("stopPeriodicEvents")]
		public static void StopPeriodicEvents()
		{
			NSApplication.EnsureUIThread();
			Messaging.void_objc_msgSend(class_ptr, selStopPeriodicEventsHandle);
		}

		[Export("mouseEventWithType:location:modifierFlags:timestamp:windowNumber:context:eventNumber:clickCount:pressure:")]
		public static NSEvent MouseEvent(NSEventType type, CGPoint location, NSEventModifierMask flags, double time, long wNum, NSGraphicsContext context, long eNum, long cNum, double pressure)
		{
			NSApplication.EnsureUIThread();
			return (NSEvent)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_UInt64_CGPoint_UInt64_Double_Int64_IntPtr_Int64_Int64_Double(class_ptr, selMouseEventWithTypeLocationModifierFlagsTimestampWindowNumberContextEventNumberClickCountPressure_Handle, (ulong)type, location, (ulong)flags, time, wNum, context?.Handle ?? IntPtr.Zero, eNum, cNum, pressure));
		}

		[Export("keyEventWithType:location:modifierFlags:timestamp:windowNumber:context:characters:charactersIgnoringModifiers:isARepeat:keyCode:")]
		public static NSEvent KeyEvent(NSEventType type, CGPoint location, NSEventModifierMask flags, double time, long wNum, NSGraphicsContext context, string keys, string ukeys, bool isARepeat, ushort code)
		{
			NSApplication.EnsureUIThread();
			if (keys == null)
			{
				throw new ArgumentNullException("keys");
			}
			if (ukeys == null)
			{
				throw new ArgumentNullException("ukeys");
			}
			IntPtr intPtr = NSString.CreateNative(keys);
			IntPtr intPtr2 = NSString.CreateNative(ukeys);
			NSEvent result = (NSEvent)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_UInt64_CGPoint_UInt64_Double_Int64_IntPtr_IntPtr_IntPtr_bool_UInt16(class_ptr, selKeyEventWithTypeLocationModifierFlagsTimestampWindowNumberContextCharactersCharactersIgnoringModifiersIsARepeatKeyCode_Handle, (ulong)type, location, (ulong)flags, time, wNum, context?.Handle ?? IntPtr.Zero, intPtr, intPtr2, isARepeat, code));
			NSString.ReleaseNative(intPtr);
			NSString.ReleaseNative(intPtr2);
			return result;
		}

		[Export("enterExitEventWithType:location:modifierFlags:timestamp:windowNumber:context:eventNumber:trackingNumber:userData:")]
		public static NSEvent EnterExitEvent(NSEventType type, CGPoint location, NSEventModifierMask flags, double time, long wNum, NSGraphicsContext context, long eNum, long tNum, IntPtr data)
		{
			NSApplication.EnsureUIThread();
			return (NSEvent)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_UInt64_CGPoint_UInt64_Double_Int64_IntPtr_Int64_Int64_IntPtr(class_ptr, selEnterExitEventWithTypeLocationModifierFlagsTimestampWindowNumberContextEventNumberTrackingNumberUserData_Handle, (ulong)type, location, (ulong)flags, time, wNum, context?.Handle ?? IntPtr.Zero, eNum, tNum, data));
		}

		[Export("otherEventWithType:location:modifierFlags:timestamp:windowNumber:context:subtype:data1:data2:")]
		public static NSEvent OtherEvent(NSEventType type, CGPoint location, NSEventModifierMask flags, double time, long wNum, NSGraphicsContext context, short subtype, long d1, long d2)
		{
			NSApplication.EnsureUIThread();
			return (NSEvent)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_UInt64_CGPoint_UInt64_Double_Int64_IntPtr_short_Int64_Int64(class_ptr, selOtherEventWithTypeLocationModifierFlagsTimestampWindowNumberContextSubtypeData1Data2_Handle, (ulong)type, location, (ulong)flags, time, wNum, context?.Handle ?? IntPtr.Zero, subtype, d1, d2));
		}

		[Export("addGlobalMonitorForEventsMatchingMask:handler:")]
		public unsafe static NSObject AddGlobalMonitorForEventsMatchingMask(NSEventMask mask, GlobalEventHandler handler)
		{
			NSApplication.EnsureUIThread();
			if (handler == null)
			{
				throw new ArgumentNullException("handler");
			}
			BlockLiteral blockLiteral = default(BlockLiteral);
			BlockLiteral* ptr = &blockLiteral;
			blockLiteral.SetupBlock(Trampolines.SDGlobalEventHandler.Handler, handler);
			NSObject nSObject = Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_UInt64_IntPtr(class_ptr, selAddGlobalMonitorForEventsMatchingMaskHandler_Handle, (ulong)mask, (IntPtr)(void*)ptr));
			ptr->CleanupBlock();
			return nSObject;
		}

		[Export("addLocalMonitorForEventsMatchingMask:handler:")]
		public unsafe static NSObject AddLocalMonitorForEventsMatchingMask(NSEventMask mask, LocalEventHandler handler)
		{
			NSApplication.EnsureUIThread();
			if (handler == null)
			{
				throw new ArgumentNullException("handler");
			}
			BlockLiteral blockLiteral = default(BlockLiteral);
			BlockLiteral* ptr = &blockLiteral;
			blockLiteral.SetupBlock(Trampolines.SDLocalEventHandler.Handler, handler);
			NSObject nSObject = Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_UInt64_IntPtr(class_ptr, selAddLocalMonitorForEventsMatchingMaskHandler_Handle, (ulong)mask, (IntPtr)(void*)ptr));
			ptr->CleanupBlock();
			return nSObject;
		}

		[Export("removeMonitor:")]
		public static void RemoveMonitor(NSObject eventMonitor)
		{
			NSApplication.EnsureUIThread();
			if (eventMonitor == null)
			{
				throw new ArgumentNullException("eventMonitor");
			}
			Messaging.void_objc_msgSend_IntPtr(class_ptr, selRemoveMonitor_Handle, eventMonitor.Handle);
		}

		[Export("trackSwipeEventWithOptions:dampenAmountThresholdMin:max:usingHandler:")]
		public unsafe virtual void TrackSwipeEvent(NSEventSwipeTrackingOptions options, double minDampenThreshold, double maxDampenThreshold, NSEventTrackHandler trackingHandler)
		{
			NSApplication.EnsureUIThread();
			if (trackingHandler == null)
			{
				throw new ArgumentNullException("trackingHandler");
			}
			BlockLiteral blockLiteral = default(BlockLiteral);
			BlockLiteral* ptr = &blockLiteral;
			blockLiteral.SetupBlock(Trampolines.SDNSEventTrackHandler.Handler, trackingHandler);
			if (IsDirectBinding)
			{
				Messaging.void_objc_msgSend_UInt64_Double_Double_IntPtr(base.Handle, selTrackSwipeEventWithOptionsDampenAmountThresholdMinMaxUsingHandler_Handle, (ulong)options, minDampenThreshold, maxDampenThreshold, (IntPtr)(void*)ptr);
			}
			else
			{
				Messaging.void_objc_msgSendSuper_UInt64_Double_Double_IntPtr(base.SuperHandle, selTrackSwipeEventWithOptionsDampenAmountThresholdMinMaxUsingHandler_Handle, (ulong)options, minDampenThreshold, maxDampenThreshold, (IntPtr)(void*)ptr);
			}
			ptr->CleanupBlock();
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			if (base.Handle == IntPtr.Zero)
			{
				__mt_Window_var = null;
				__mt_Context_var = null;
				__mt_TrackingArea_var = null;
				__mt_VendorDefined_var = null;
			}
		}
	}
}
