internal RawStylusInputReport(
            InputMode mode,
            int timestamp,
            PresentationSource inputSource,
            PenContext penContext,
            RawStylusActions actions,
            int tabletDeviceId,
            int stylusDeviceId,
            int[] data)
            : base(inputSource, InputType.Stylus, mode, timestamp)
        {
            // Validate parameters
            if (!RawStylusActionsHelper.IsValid(actions))
            {
                throw new InvalidEnumArgumentException(SR.Get(SRID.Enum_Invalid, "actions"));
            }
            if (data == null && actions != RawStylusActions.InRange)
            {
                throw new ArgumentNullException("data");
            }

            _penContext     = new SecurityCriticalDataClass<PenContext>(penContext);
            _actions        = actions;
            _tabletDeviceId = tabletDeviceId;
            _stylusDeviceId = stylusDeviceId;
            _data           = data;
            _isSynchronize  = false;
        }

        public static Size FromPixels(PresentationSource source, Size pixelSize) {
            if (source == null) {
                throw new ArgumentNullException(nameof(source));
            }

            return (Size)source.CompositionTarget.TransformFromDevice.Transform((Vector)pixelSize);
        }

        internal static Rect ElementToRoot(Rect rectElement, Visual element, PresentationSource presentationSource)
        {
            GeneralTransform transformElementToRoot = element.TransformToAncestor(presentationSource.RootVisual);
            Rect rectRoot = transformElementToRoot.TransformBounds(rectElement);

            return rectRoot;
        }

        public static Point ToPixels(PresentationSource source, Point wpfSize) {
            if (source == null) {
                throw new ArgumentNullException(nameof(source));
            }

            return (Point)source.CompositionTarget.TransformToDevice.Transform((Vector)wpfSize);
        }

 public KinectTouchDevice(int id, PresentationSource source)
     : base(id)
 {
     this.Position = new Point();
     this.TouchState = TouchState.Up;
     this.SetActiveSource(source);
 }

		public static Point TryClientToRoot(Point point, PresentationSource source, bool throwOnError, out bool success)
		{
			success = default(bool);
			object[] parameters = new object[] { point, source, throwOnError, success };
			Point result = (Point)tryClientToRootMethod.Invoke(null, parameters);
			success = (bool)parameters[3];
			return result;
		}

        public static int GetResolution(PresentationSource source) {
            if (source == null) {
                throw new ArgumentNullException(nameof(source));
            }

            int res = (int)(96 * source.CompositionTarget.TransformToDevice.M11);
            return res;
        }

        public PresentationSourceTreeItem(PresentationSource presentationSource, TreeModel model, TreeType treeType)
            : base(presentationSource, null, model, 0)
        {
            Name = "PresentationSource";
            IsExpanded = true;

            _treeType = treeType;
            _presentationSource = presentationSource;
        }

 public KinectMultiTouchDevice(IHandDataSource handDataSource, FrameworkElement area)
 {
     this.touchDevices = new Dictionary<int, KinectTouchDevice>();
     this.TargetSize = new Size(area.ActualWidth, area.ActualHeight);
     this.presentationSource = PresentationSource.FromVisual(area);
     this.handDataSource = handDataSource;
     handDataSource.NewDataAvailable += new Core.NewDataHandler<HandCollection>(handDataSource_NewDataAvailable);
     area.SizeChanged += new SizeChangedEventHandler(area_SizeChanged);
 }

        internal static Rect RootToClient(Rect rectRoot, PresentationSource presentationSource)
        {
            CompositionTarget target = presentationSource.CompositionTarget;
            Matrix matrixRootTransform = PointUtil.GetVisualTransform(target.RootVisual);
            Rect rectRootUntransformed = Rect.Transform(rectRoot, matrixRootTransform);
            Matrix matrixDPI = target.TransformToDevice;
            Rect rectClient = Rect.Transform(rectRootUntransformed, matrixDPI);

            return rectClient;
        }

 public SourceChangedEventArgs(PresentationSource oldSource,
                               PresentationSource newSource, 
                               IInputElement element,
                               IInputElement oldParent) 
 { 
     _oldSource = new SecurityCriticalData<PresentationSource>(oldSource);
     _newSource = new SecurityCriticalData<PresentationSource>(newSource); 
     _element = element;
     _oldParent = oldParent;
 }

 /// <summary>
 ///     Constructs ad instance of the RawAppCommandInputReport class.
 /// </summary>
 /// <param name="inputSource">
 ///     The input source that provided this input.
 /// </param>
 /// <param name="mode">
 ///     The mode in which the input is being provided.
 /// </param>
 /// <param name="timestamp">
 ///     The time when the input occured.
 /// </param>
 /// <param name="appCommand">
 ///     The Application Command associated.
 /// </param>
 /// <param name="device">
 ///     The device that generated the app command.
 /// </param>
 /// <param name="inputType">the input device that generated the input event</param>
 internal RawAppCommandInputReport(
     PresentationSource  inputSource,
     InputMode           mode,
     int                 timestamp,
     int                 appCommand,
     InputType           device,
     InputType           inputType) : base(inputSource, inputType, mode, timestamp)
 {
     _appCommand = appCommand;
     _device = device;
 }

        internal PenContexts(StylusLogic stylusLogic, PresentationSource inputSource)
        {
            HwndSource hwndSource = inputSource as HwndSource;
            if(hwndSource == null || IntPtr.Zero == (hwndSource).CriticalHandle)
            {
                throw new InvalidOperationException(SR.Get(SRID.Stylus_PenContextFailure));
            }

            _stylusLogic  = stylusLogic;
            _inputSource   = new SecurityCriticalData<HwndSource>(hwndSource);
        }

        protected InputReport(PresentationSource inputSource, InputType type, InputMode mode, int timestamp)
        {
            if (inputSource == null)
                throw new ArgumentNullException("inputSource");

            Validate_InputType( type );
            Validate_InputMode( mode );
            _inputSource= new SecurityCriticalData<PresentationSource>(inputSource);
            _type = type;
            _mode = mode;
            _timestamp = timestamp;
        }

        public static Point RootToClient(Point point, PresentationSource presentationSource)
        {
            // 


            point = ApplyVisualTransform(point, presentationSource.RootVisual, false);

            // Convert from measure units into pixels.
            point = presentationSource.CompositionTarget.TransformToDevice.Transform(point);

            return point;
        }

		public MultitouchInputProvider(PresentationSource source)
		{
			this.source = source;
			contactsQueue = new Queue<RawMultitouchReport>();
			inputManagerProcessInput = InputManagerProcessInput;

            contactHandler = new ContactHandler(((HwndSource)source).Handle);
            contactHandler.ContactMoved += HandleContact;
            contactHandler.ContactRemoved += HandleContact;
            contactHandler.NewContact += HandleContact;

			inputManager = InputManager.Current;
			multitouchLogic = MultitouchLogic.Current;
		}

        public MotionTrackingDevice(Window window, MotionTrackingScreen screen)
            : base()
        {
            if (window == null)
                throw new ArgumentNullException("window");
            if (screen == null)
                throw new ArgumentNullException("screen");

            this.screen = screen;
            this.rootWindow = window;
            _activeSource = PresentationSource.FromVisual(window);

            Activate();
        }

        public RawUIStateInputReport(
            PresentationSource inputSource,
            InputMode mode,
            int timestamp,
            RawUIStateActions action,
            RawUIStateTargets targets) : base(inputSource, InputType.Keyboard, mode, timestamp)
        {
            if (!IsValidRawUIStateAction(action))
                throw new System.ComponentModel.InvalidEnumArgumentException("action", (int)action, typeof(RawUIStateActions));
            if (!IsValidRawUIStateTargets(targets))
                throw new System.ComponentModel.InvalidEnumArgumentException("targets", (int)targets, typeof(RawUIStateTargets));

            _action = action;
            _targets = targets;
        }

        /// <summary> 
        ///     Constructs ad instance of the RawKeyboardInputReport class.
        /// </summary> 
        /// <param name="inputSource">
        ///     The input source that provided this input.
        /// </param>
        /// <param name="mode"> 
        ///     The mode in which the input is being provided.
        /// </param> 
        /// <param name="timestamp"> 
        ///     The time when the input occured.
        /// </param> 
        /// <param name="isDeadCharacter">
        ///     True if the char code is a dead char.
        /// </param>
        /// <param name="isSystemCharacter"> 
        ///     True if the char code is a system char.
        /// </param> 
        /// <param name="isControlCharacter"> 
        ///     True if the char code is a control char.
        /// </param> 
        /// <param name="characterCode">
        ///     The character code.
        /// </param>
        public RawTextInputReport( 
            PresentationSource inputSource,
            InputMode mode, 
            int timestamp, 
            bool isDeadCharacter,
            bool isSystemCharacter, 
            bool isControlCharacter,
            char characterCode) : base(inputSource, InputType.Text, mode, timestamp)
        {
            _isDeadCharacter = isDeadCharacter; 
            _isSystemCharacter = isSystemCharacter;
            _isControlCharacter = isControlCharacter; 
 
            _characterCode = characterCode;
        } 

        public RawKeyboardInputReport(
            PresentationSource inputSource,
            InputMode mode,
            int timestamp, 
            RawKeyboardActions actions, 
            int scanCode, 
            bool isExtendedKey,
            bool isSystemKey,
            int virtualKey, 
            IntPtr extraInformation) : base(inputSource, InputType.Keyboard, mode, timestamp)
        {
            if (!IsValidRawKeyboardActions(actions))
                throw new System.ComponentModel.InvalidEnumArgumentException("actions", (int)actions, typeof(RawKeyboardActions));

            _actions = actions;
            _scanCode = scanCode;
            _isExtendedKey = isExtendedKey;
            _isSystemKey = isSystemKey;
            _virtualKey = virtualKey;
            _extraInformation = new SecurityCriticalData<IntPtr>(extraInformation);
        }