C# Windows.PresentationSource类代码示例

        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;
        }