internal void UpdateSizeDeltas(StylusPointDescription description, WispLogic stylusLogic) { // Query default settings for mouse drag and double tap (with minimum of 1x1 size). Size mouseDragDefault = new Size(Math.Max(1, SafeSystemMetrics.DragDeltaX / 2), Math.Max(1, SafeSystemMetrics.DragDeltaY / 2)); Size mouseDoubleTapDefault = new Size(Math.Max(1, SafeSystemMetrics.DoubleClickDeltaX / 2), Math.Max(1, SafeSystemMetrics.DoubleClickDeltaY / 2)); StylusPointPropertyInfo xProperty = description.GetPropertyInfo(StylusPointProperties.X); StylusPointPropertyInfo yProperty = description.GetPropertyInfo(StylusPointProperties.Y); uint dwXValue = GetPropertyValue(xProperty); uint dwYValue = GetPropertyValue(yProperty); if (dwXValue != 0 && dwYValue != 0) { _cancelSize = new Size((int)Math.Round((ScreenSize.Width * stylusLogic.CancelDelta) / dwXValue), (int)Math.Round((ScreenSize.Height * stylusLogic.CancelDelta) / dwYValue)); // Make sure we return whole numbers (pixels are whole numbers) and take the maximum // value between mouse and stylus settings to be safe. _cancelSize.Width = Math.Max(mouseDragDefault.Width, _cancelSize.Width); _cancelSize.Height = Math.Max(mouseDragDefault.Height, _cancelSize.Height); _doubleTapSize = new Size((int)Math.Round((ScreenSize.Width * stylusLogic.DoubleTapDelta) / dwXValue), (int)Math.Round((ScreenSize.Height * stylusLogic.DoubleTapDelta) / dwYValue)); // Make sure we return whole numbers (pixels are whole numbers) and take the maximum // value between mouse and stylus settings to be safe. _doubleTapSize.Width = Math.Max(mouseDoubleTapDefault.Width, _doubleTapSize.Width); _doubleTapSize.Height = Math.Max(mouseDoubleTapDefault.Height, _doubleTapSize.Height); } else { // If no info to do the calculation then use the mouse settings for the default. _doubleTapSize = mouseDoubleTapDefault; _cancelSize = mouseDragDefault; } _forceUpdateSizeDeltas = false; }
protected static uint GetPropertyValue(StylusPointPropertyInfo propertyInfo) { uint dw = DefaultPropertyValue; switch (propertyInfo.Unit) { case StylusPointPropertyUnit.Inches: if (propertyInfo.Resolution != 0) { dw = (uint)(((propertyInfo.Maximum - propertyInfo.Minimum) * 254) / propertyInfo.Resolution); } break; case StylusPointPropertyUnit.Centimeters: if (propertyInfo.Resolution != 0) { dw = (uint)(((propertyInfo.Maximum - propertyInfo.Minimum) * 100) / propertyInfo.Resolution); } break; } return(dw); }
/// <summary> /// Returns true if the two StylusPointDescriptions have the same StylusPointProperties. Metrics are ignored. /// </summary> /// <param name="stylusPointDescription1">stylusPointDescription1</param> /// <param name="stylusPointDescription2">stylusPointDescription2</param> public static bool AreCompatible(StylusPointDescription stylusPointDescription1, StylusPointDescription stylusPointDescription2) { if (stylusPointDescription1 == null || stylusPointDescription2 == null) { throw new ArgumentNullException("stylusPointDescription"); } #pragma warning disable 6506 // if a StylusPointDescription is not null, then _stylusPointPropertyInfos is not null. // // ignore X, Y, Pressure - they are guaranteed to be the first3 members // Debug.Assert(stylusPointDescription1._stylusPointPropertyInfos.Length >= RequiredCountOfProperties && stylusPointDescription1._stylusPointPropertyInfos[0].Id == StylusPointPropertyIds.X && stylusPointDescription1._stylusPointPropertyInfos[1].Id == StylusPointPropertyIds.Y && stylusPointDescription1._stylusPointPropertyInfos[2].Id == StylusPointPropertyIds.NormalPressure); Debug.Assert(stylusPointDescription2._stylusPointPropertyInfos.Length >= RequiredCountOfProperties && stylusPointDescription2._stylusPointPropertyInfos[0].Id == StylusPointPropertyIds.X && stylusPointDescription2._stylusPointPropertyInfos[1].Id == StylusPointPropertyIds.Y && stylusPointDescription2._stylusPointPropertyInfos[2].Id == StylusPointPropertyIds.NormalPressure); if (stylusPointDescription1._stylusPointPropertyInfos.Length != stylusPointDescription2._stylusPointPropertyInfos.Length) { return(false); } for (int x = RequiredCountOfProperties; x < stylusPointDescription1._stylusPointPropertyInfos.Length; x++) { if (!StylusPointPropertyInfo.AreCompatible(stylusPointDescription1._stylusPointPropertyInfos[x], stylusPointDescription2._stylusPointPropertyInfos[x])) { return(false); } } #pragma warning restore 6506 return(true); }
public MetricEntryList (KnownTagCache.KnownTagIndex tag, StylusPointPropertyInfo prop) { Tag = tag; PropertyMetrics = prop; }
/// <summary> /// This function checks if this packet property results in a valid metric entry. This will be a valid entry if /// 1. it is a custom property, 2. Does not belong to the global list of gaMetricEntry_Never, 3. Belongs to the /// global list of gaMetricEntry_Must and 4. Belongs to global list of gaMetricEntry_Optional and at least one of /// its metric values is different from the corresponding default. /// </summary> /// <param name="propertyInfo"></param> /// <param name="tag"></param> /// <param name="metricEntryType"></param> /// <param name="index"></param> /// <returns></returns> static bool IsValidMetricEntry(StylusPointPropertyInfo propertyInfo, KnownTagCache.KnownTagIndex tag, out MetricEntryType metricEntryType, out uint index) { index = 0; // If this is a custom property, check if all the Metric values are null or not. If they are then this is not a // valid metric entry if (tag >= (KnownTagCache.KnownTagIndex)KnownIdCache.CustomGuidBaseIndex) { metricEntryType = MetricEntryType.Custom; if( Int32.MinValue == propertyInfo.Minimum && Int32.MaxValue == propertyInfo.Maximum && StylusPointPropertyUnit.None == propertyInfo.Unit && DoubleUtil.AreClose(1.0, propertyInfo.Resolution) ) return false; else return true; } else { int ul; // First find the property in the gaMetricEntry_Never. If it belongs to this list, // we will never write the metric table for this prop. So return FALSE; for( ul = 0; ul < MetricEntry_Never.Length ; ul++ ) { if( MetricEntry_Never[ul] == tag ) { metricEntryType = MetricEntryType.Never; return false; } } // Then search the property in the gaMetricEntry_Must list. If it belongs to this list, // we must always write the metric table for this prop. So return TRUE; for( ul = 0; ul<MetricEntry_Must.Length; ul++ ) { if( MetricEntry_Must[ul] == tag ) { metricEntryType = MetricEntryType.Must; if( propertyInfo.Minimum == DefaultPropertyMetrics.Minimum && propertyInfo.Maximum == DefaultPropertyMetrics.Maximum && propertyInfo.Unit == DefaultPropertyMetrics.Unit && DoubleUtil.AreClose(propertyInfo.Resolution, DefaultPropertyMetrics.Resolution )) return false; else return true; } } // Now seach it in the gaMetricEntry_Optional list. If it is there, check the metric values // agianst the default values and if there is any non default value, return TRUE; for( ul = 0; ul<MetricEntry_Optional.Length; ul++ ) { if( ((MetricEntryList)MetricEntry_Optional[ul]).Tag == tag ) { metricEntryType = MetricEntryType.Optional; if( propertyInfo.Minimum == MetricEntry_Optional[ul].PropertyMetrics.Minimum && propertyInfo.Maximum == MetricEntry_Optional[ul].PropertyMetrics.Maximum && propertyInfo.Unit == MetricEntry_Optional[ul].PropertyMetrics.Unit && DoubleUtil.AreClose(propertyInfo.Resolution, MetricEntry_Optional[ul].PropertyMetrics.Resolution) ) return false; else { index = (uint)ul; return true; } } } // it is not found in any of the list. Force to write all metric entries for the property. metricEntryType = MetricEntryType.Must; return true; } }
/// <summary> /// Creates a metric entry based on a PropertyInfo and Tag and returns the Metric Entry Type created /// </summary> /// <param name="propertyInfo"></param> /// <param name="tag"></param> /// <returns></returns> public MetricEntryType CreateMetricEntry(StylusPointPropertyInfo propertyInfo, KnownTagCache.KnownTagIndex tag) { // First create the default Metric entry based on the property and type of metric entry and then use that to initialize the // metric entry data. uint index = 0; Tag = tag; MetricEntryType type; if( IsValidMetricEntry(propertyInfo, Tag, out type, out index) ) { switch(type) { case MetricEntryType.Optional: { Initialize(propertyInfo, MetricEntry_Optional[index].PropertyMetrics); break; } case MetricEntryType.Must : case MetricEntryType.Custom: Initialize(propertyInfo, DefaultPropertyMetrics); break; default: throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("MetricEntryType was persisted with Never flag which should never happen")); } } return type; }
/// <summary> /// Initializes a MetricEntry based on StylusPointPropertyInfo and default StylusPointPropertyInfo for the property /// </summary> /// <param name="originalInfo"></param> /// <param name="defaultInfo"></param> /// <returns></returns> public void Initialize(StylusPointPropertyInfo originalInfo, StylusPointPropertyInfo defaultInfo) { _size = 0; using (MemoryStream strm = new MemoryStream(_data)) { if (!DoubleUtil.AreClose(originalInfo.Resolution, defaultInfo.Resolution)) { // First min value _size += SerializationHelper.SignEncode(strm, originalInfo.Minimum); // Max value _size += SerializationHelper.SignEncode(strm, originalInfo.Maximum); // Units _size += SerializationHelper.Encode(strm, (uint)originalInfo.Unit); // resolution using (BinaryWriter bw = new BinaryWriter(strm)) { bw.Write(originalInfo.Resolution); _size += 4; // sizeof(float) } } else if (originalInfo.Unit != defaultInfo.Unit) { // First min value _size += SerializationHelper.SignEncode(strm, originalInfo.Minimum); // Max value _size += SerializationHelper.SignEncode(strm, originalInfo.Maximum); // Units _size += SerializationHelper.Encode(strm, (uint)originalInfo.Unit); } else if (originalInfo.Maximum != defaultInfo.Maximum) { // First min value _size += SerializationHelper.SignEncode(strm, originalInfo.Minimum); // Max value _size += SerializationHelper.SignEncode(strm, originalInfo.Maximum); } else if (originalInfo.Minimum != defaultInfo.Minimum) { _size += SerializationHelper.SignEncode(strm, originalInfo.Minimum); } } }
/// <summary> /// Builds StylusPointDescription based on StrokeDescriptor and Metric Descriptor Block. Sometime Metric Descriptor block may contain /// metric information for properties which are not part of the stroke descriptor. They are simply ignored. /// </summary> /// <param name="strd"></param> /// <param name="block"></param> /// <param name="guidList"></param> /// <returns></returns> private StylusPointDescription BuildStylusPointDescription(StrokeDescriptor strd, MetricBlock block, GuidList guidList) { int cTags = 0; int packetPropertyCount = 0; uint buttonCount = 0; Guid[] buttonguids = null; System.Collections.Generic.List<KnownTagCache.KnownTagIndex> tags = null; // if strd is null, it means there is only default descriptor with X & Y if (null != strd) { tags = new System.Collections.Generic.List<KnownTagCache.KnownTagIndex>(); while (cTags < strd.Template.Count) { KnownTagCache.KnownTagIndex tag = (KnownTagCache.KnownTagIndex)strd.Template[cTags]; if (KnownTagCache.KnownTagIndex.Buttons == tag) { cTags++; // The next item in the array is no of buttongs. buttonCount = (uint)strd.Template[cTags]; cTags++; // Currently we skip the the no of buttons as buttons is not implimented yet buttonguids = new Guid[buttonCount]; for (uint u = 0; u < buttonCount; u++) { Guid guid = guidList.FindGuid(strd.Template[cTags]); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Button guid tag embedded in ISF stream does not match guid table"),"strd"); } buttonguids[(int)u] = guid; cTags++; } } else if (KnownTagCache.KnownTagIndex.StrokePropertyList == tag) { break; // since no more Packet properties can be stored } else { if (KnownTagCache.KnownTagIndex.NoX == tag || KnownTagCache.KnownTagIndex.NoY == tag) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF with NoX or NoY specified"), "strd"); } tags.Add(strd.Template[cTags]); packetPropertyCount++; cTags++; } } } List<StylusPointPropertyInfo> stylusPointPropertyInfos = new List<StylusPointPropertyInfo>(); stylusPointPropertyInfos.Add(GetStylusPointPropertyInfo(KnownIds.X, (KnownTagCache.KnownTagIndex)((uint)KnownIdCache.KnownGuidBaseIndex + (uint)KnownIdCache.OriginalISFIdIndex.X), block)); stylusPointPropertyInfos.Add(GetStylusPointPropertyInfo(KnownIds.Y, (KnownTagCache.KnownTagIndex)((uint)KnownIdCache.KnownGuidBaseIndex + (uint)KnownIdCache.OriginalISFIdIndex.Y), block)); stylusPointPropertyInfos.Add(GetStylusPointPropertyInfo(KnownIds.NormalPressure, (KnownTagCache.KnownTagIndex)((uint)KnownIdCache.KnownGuidBaseIndex + (uint)KnownIdCache.OriginalISFIdIndex.NormalPressure), block)); int pressureIndex = -1; if (tags != null) { for (int i = 0; i < tags.Count; i++) { Guid guid = guidList.FindGuid(tags[i]); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Packet Description Property tag embedded in ISF stream does not match guid table"), "strd"); } if (pressureIndex == -1 && guid == StylusPointPropertyIds.NormalPressure) { pressureIndex = i + 2; //x,y have already been accounted for continue; //we've already added pressure (above) } stylusPointPropertyInfos.Add(GetStylusPointPropertyInfo(guid, tags[i], block)); } if (null != buttonguids) { // // add the buttons to the end of the description if they exist // for (int i = 0; i < buttonguids.Length; i++) { StylusPointProperty buttonProperty = new StylusPointProperty(buttonguids[i], true); StylusPointPropertyInfo buttonInfo = new StylusPointPropertyInfo(buttonProperty); stylusPointPropertyInfos.Add(buttonInfo); } } } return new StylusPointDescription(stylusPointPropertyInfos, pressureIndex); }
/// <summary> /// ToISFReadyArrays - Returns an array of arrays of packet values: /// /// int[] /// - int[x,x,x,x,x,x] /// - int[y,y,y,y,y,y] /// - int[p,p,p,p,p,p] /// /// For ISF serialization /// /// Also returns if any non-default pressures were found or the metric for /// pressure was non-default /// /// </summary> internal void ToISFReadyArrays(out int[][] output, out bool shouldPersistPressure) { Debug.Assert(this.Count != 0, "Why are we serializing an empty StylusPointCollection???"); // // X and Y are in Avalon units, we need to convert to HIMETRIC // // // int lengthPerPoint = this.Description.GetOutputArrayLengthPerPoint(); if (this.Description.ButtonCount > 0) { //don't serialize button data. See Windows OS Bugs 1413460 for details lengthPerPoint--; } output = new int[lengthPerPoint][]; for (int x = 0; x < lengthPerPoint; x++) { output[x] = new int[this.Count]; } // // we serialize pressure if // 1) The StylusPointPropertyInfo for pressure is not the default // 2) There is at least one non-default pressure value in this SPC // StylusPointPropertyInfo pressureInfo = this.Description.GetPropertyInfo(StylusPointPropertyIds.NormalPressure); shouldPersistPressure = !StylusPointPropertyInfo.AreCompatible(pressureInfo, StylusPointPropertyInfoDefaults.NormalPressure); for (int b = 0; b < this.Count; b++) { StylusPoint stylusPoint = this[b]; output[0][b] = (int)Math.Round(stylusPoint.X * StrokeCollectionSerializer.AvalonToHimetricMultiplier); output[1][b] = (int)Math.Round(stylusPoint.Y * StrokeCollectionSerializer.AvalonToHimetricMultiplier); output[2][b] = stylusPoint.GetPropertyValue(StylusPointProperties.NormalPressure); // // it's not necessary to check HasDefaultPressure if // allDefaultPressures is already set // if (!shouldPersistPressure && !stylusPoint.HasDefaultPressure) { shouldPersistPressure = true; } if (lengthPerPoint > StylusPointDescription.RequiredCountOfProperties) { int[] additionalData = stylusPoint.GetAdditionalData(); int countToCopy = lengthPerPoint - StylusPointDescription.RequiredCountOfProperties;/*3*/ Debug.Assert(this.Description.ButtonCount > 0 ? additionalData.Length - 1 == countToCopy : additionalData.Length == countToCopy); for (int y = 0; y < countToCopy; y++) { output[y + 3][b] = additionalData[y]; } } } }
private void GetPacketData ( Stroke stroke, out MS.Win32.Recognizer.PACKET_DESCRIPTION packetDescription, out int countOfBytes, out IntPtr packets, out NativeMethods.XFORM xForm ) { int i; countOfBytes = 0; packets = IntPtr.Zero; packetDescription = new MS.Win32.Recognizer.PACKET_DESCRIPTION(); Matrix matrix = Matrix.Identity; xForm = new NativeMethods.XFORM((float)(matrix.M11), (float)(matrix.M12), (float)(matrix.M21), (float)(matrix.M22), (float)(matrix.OffsetX), (float)(matrix.OffsetY)); StylusPointCollection stylusPoints = stroke.StylusPoints; if (stylusPoints.Count == 0) { return; //we'll fail when the calling routine sees that packets is IntPtr.Zer } if (stylusPoints.Description.PropertyCount > StylusPointDescription.RequiredCountOfProperties) { // // reformat to X, Y, P // StylusPointDescription reformatDescription = new StylusPointDescription( new StylusPointPropertyInfo[]{ new StylusPointPropertyInfo(StylusPointProperties.X), new StylusPointPropertyInfo(StylusPointProperties.Y), stylusPoints.Description.GetPropertyInfo(StylusPointProperties.NormalPressure)}); stylusPoints = stylusPoints.Reformat(reformatDescription); } // // now make sure we only take a finite amount of data for the stroke // if (stylusPoints.Count > MaxStylusPoints) { stylusPoints = stylusPoints.Clone(MaxStylusPoints); } Guid[] propertyGuids = new Guid[]{ StylusPointPropertyIds.X, //required index for SPD StylusPointPropertyIds.Y, //required index for SPD StylusPointPropertyIds.NormalPressure}; //required index for SPD Debug.Assert(stylusPoints != null); Debug.Assert(propertyGuids.Length == StylusPointDescription.RequiredCountOfProperties); // Get the packet description packetDescription.cbPacketSize = (uint)(propertyGuids.Length * Marshal.SizeOf(typeof(Int32))); packetDescription.cPacketProperties = (uint)propertyGuids.Length; // // use X, Y defaults for metrics, sometimes mouse metrics can be bogus // always use NormalPressure metrics, though. // StylusPointPropertyInfo[] infosToUse = new StylusPointPropertyInfo[StylusPointDescription.RequiredCountOfProperties]; infosToUse[StylusPointDescription.RequiredXIndex] = StylusPointPropertyInfoDefaults.X; infosToUse[StylusPointDescription.RequiredYIndex] = StylusPointPropertyInfoDefaults.Y; infosToUse[StylusPointDescription.RequiredPressureIndex] = stylusPoints.Description.GetPropertyInfo(StylusPointProperties.NormalPressure); MS.Win32.Recognizer.PACKET_PROPERTY[] packetProperties = new MS.Win32.Recognizer.PACKET_PROPERTY[packetDescription.cPacketProperties]; StylusPointPropertyInfo propertyInfo; for ( i = 0; i < packetDescription.cPacketProperties; i++ ) { packetProperties[i].guid = propertyGuids[i]; propertyInfo = infosToUse[i]; MS.Win32.Recognizer.PROPERTY_METRICS propertyMetrics = new MS.Win32.Recognizer.PROPERTY_METRICS( ); propertyMetrics.nLogicalMin = propertyInfo.Minimum; propertyMetrics.nLogicalMax = propertyInfo.Maximum; propertyMetrics.Units = (int)(propertyInfo.Unit); propertyMetrics.fResolution = propertyInfo.Resolution; packetProperties[i].PropertyMetrics = propertyMetrics; } unsafe { int allocationSize = (int)(Marshal.SizeOf(typeof(MS.Win32.Recognizer.PACKET_PROPERTY)) * packetDescription.cPacketProperties); packetDescription.pPacketProperties = Marshal.AllocCoTaskMem(allocationSize); MS.Win32.Recognizer.PACKET_PROPERTY* pPacketProperty = (MS.Win32.Recognizer.PACKET_PROPERTY*)(packetDescription.pPacketProperties.ToPointer()); MS.Win32.Recognizer.PACKET_PROPERTY* pElement = pPacketProperty; for ( i = 0 ; i < packetDescription.cPacketProperties ; i ++ ) { Marshal.StructureToPtr(packetProperties[i], new IntPtr(pElement), false); pElement++; } } // Get packet data int[] rawPackets = stylusPoints.ToHiMetricArray(); int packetCount = rawPackets.Length; if (packetCount != 0) { countOfBytes = packetCount * Marshal.SizeOf(typeof(Int32)); packets = Marshal.AllocCoTaskMem(countOfBytes); Marshal.Copy(rawPackets, 0, packets, packetCount); } }
/// <summary> /// Optimization that lets the ctor call setvalue repeatly without causing a copy of the int[] /// </summary> /// <param name="stylusPointProperty">stylusPointProperty</param> /// <param name="value">value</param> /// <param name="copyBeforeWrite"></param> internal void SetPropertyValue(StylusPointProperty stylusPointProperty, int value, bool copyBeforeWrite) { if (null == stylusPointProperty) { throw new ArgumentNullException("stylusPointProperty"); } if (stylusPointProperty.Id == StylusPointPropertyIds.X) { double dVal = (double)value; // // only accept values between MaxXY and MinXY // we don't throw when passed a value outside of that range, we just silently trunctate // _x = GetClampedXYValue(dVal); } else if (stylusPointProperty.Id == StylusPointPropertyIds.Y) { double dVal = (double)value; // // only accept values between MaxXY and MinXY // we don't throw when passed a value outside of that range, we just silently trunctate // _y = GetClampedXYValue(dVal); } else if (stylusPointProperty.Id == StylusPointPropertyIds.NormalPressure) { StylusPointPropertyInfo info = this.Description.GetPropertyInfo(StylusPointProperties.NormalPressure); int min = info.Minimum; int max = info.Maximum; if (max == 0) { _pressureFactor = 0.0f; } else { _pressureFactor = (float)(Convert.ToSingle(min + value) / Convert.ToSingle(max)); } } else { int propertyIndex = this.Description.GetPropertyIndex(stylusPointProperty.Id); if (-1 == propertyIndex) { throw new ArgumentException(SR.Get(SRID.InvalidStylusPointProperty), "propertyId"); } if (stylusPointProperty.IsButton) { if (value < 0 || value > 1) { throw new ArgumentOutOfRangeException("value", SR.Get(SRID.InvalidMinMaxForButton)); } if (copyBeforeWrite) { CopyAdditionalData(); } // // we get button data from a single int in the array // int buttonData = _additionalValues[_additionalValues.Length - 1]; int buttonBitPosition = this.Description.GetButtonBitPosition(stylusPointProperty); int bit = 1 << buttonBitPosition; if (value == 0) { //turn the bit off buttonData &= ~bit; } else { //turn the bit on buttonData |= bit; } _additionalValues[_additionalValues.Length - 1] = buttonData; } else { if (copyBeforeWrite) { CopyAdditionalData(); } _additionalValues[propertyIndex - 3] = value; } } }
private static uint GetPropertyValue(StylusPointPropertyInfo propertyInfo) { uint dw = 0; switch (propertyInfo.Unit) { case StylusPointPropertyUnit.Inches: if (propertyInfo.Resolution != 0) dw = (uint) (((propertyInfo.Maximum - propertyInfo.Minimum) * 254) / propertyInfo.Resolution); break; case StylusPointPropertyUnit.Centimeters: if (propertyInfo.Resolution != 0) dw = (uint) (((propertyInfo.Maximum - propertyInfo.Minimum) * 100) / propertyInfo.Resolution); break; default: dw = 1000; break; } return dw; }
private void InitStylusPointDescription() { int cProps; int cButtons; int pressureIndex = -1; // Make sure we are never called on the application thread when we need to talk // to penimc or else we can cause reentrancy! Debug.Assert(!_contexts._inputSource.Value.CheckAccess()); // We should always have a valid IPimcContext interface pointer. Debug.Assert(_pimcContext != null && _pimcContext.Value != null); _pimcContext.Value.GetPacketDescriptionInfo(out cProps, out cButtons); // Calls Unmanaged code - SecurityCritical with SUC. List<StylusPointPropertyInfo> propertyInfos = new List<StylusPointPropertyInfo>(cProps + cButtons + 3); for (int i = 0; i < cProps; i++) { Guid guid; int min, max; int units; float res; _pimcContext.Value.GetPacketPropertyInfo(i, out guid, out min, out max, out units, out res); // Calls Unmanaged code - SecurityCritical with SUC. if (pressureIndex == -1 && guid == StylusPointPropertyIds.NormalPressure) { pressureIndex = i; } if (_statusPropertyIndex == -1 && guid == StylusPointPropertyIds.PacketStatus) { _statusPropertyIndex = i; } StylusPointPropertyInfo propertyInfo = new StylusPointPropertyInfo(new StylusPointProperty(guid, false), min, max, (StylusPointPropertyUnit)units, res); propertyInfos.Add(propertyInfo); } Debug.Assert(_statusPropertyIndex != -1); // We should always see this. // Make sure we actually created propertyInfos OK if (propertyInfos != null) { for (int i = 0; i < cButtons; i++) { Guid buttonGuid; _pimcContext.Value.GetPacketButtonInfo(i, out buttonGuid); // Calls Unmanaged code - SecurityCritical with SUC. StylusPointProperty buttonProperty = new StylusPointProperty(buttonGuid, true); StylusPointPropertyInfo buttonInfo = new StylusPointPropertyInfo(buttonProperty); propertyInfos.Add(buttonInfo); } //validate we can never get X, Y at index != 0, 1 Debug.Assert(propertyInfos[StylusPointDescription.RequiredXIndex /*0*/].Id == StylusPointPropertyIds.X, "X isn't where we expect it! Fix PenImc to ask for X at index 0"); Debug.Assert(propertyInfos[StylusPointDescription.RequiredYIndex /*0*/].Id == StylusPointPropertyIds.Y, "Y isn't where we expect it! Fix PenImc to ask for Y at index 1"); Debug.Assert(pressureIndex == -1 || pressureIndex == StylusPointDescription.RequiredPressureIndex /*2*/, "Fix PenImc to ask for NormalPressure at index 2!"); if (pressureIndex == -1) { //pressure wasn't found. Add it propertyInfos.Insert(StylusPointDescription.RequiredPressureIndex /*2*/, StylusPointPropertyInfoDefaults.NormalPressure); } _infoX = propertyInfos[0]; _infoY = propertyInfos[1]; _stylusPointDescription = new StylusPointDescription(propertyInfos, pressureIndex); } }
/// <summary> /// Internal helper method for comparing compat for two StylusPointPropertyInfos /// </summary> internal static bool AreCompatible(StylusPointPropertyInfo stylusPointPropertyInfo1, StylusPointPropertyInfo stylusPointPropertyInfo2) { if (stylusPointPropertyInfo1 == null || stylusPointPropertyInfo2 == null) { throw new ArgumentNullException("stylusPointPropertyInfo"); } Debug.Assert((stylusPointPropertyInfo1.Id != StylusPointPropertyIds.X && stylusPointPropertyInfo1.Id != StylusPointPropertyIds.Y && stylusPointPropertyInfo2.Id != StylusPointPropertyIds.X && stylusPointPropertyInfo2.Id != StylusPointPropertyIds.Y), "Why are you checking X, Y for compatibility? They're always compatible"); // // we only take ID and IsButton into account, we don't take metrics into account // return(stylusPointPropertyInfo1.Id == stylusPointPropertyInfo2.Id && stylusPointPropertyInfo1.IsButton == stylusPointPropertyInfo2.IsButton); }
/// <summary> /// Adds a new metric entry in the existing list of metric entries /// </summary> /// <param name="property"></param> /// <param name="tag"></param> /// <returns></returns> public MetricEntryType AddMetricEntry(StylusPointPropertyInfo property, KnownTagCache.KnownTagIndex tag) { // Create a new metric entry based on the packet information passed. MetricEntry entry = new MetricEntry(); MetricEntryType type = entry.CreateMetricEntry(property, tag); // Don't add this entry to the global list if size is 0, means default metric values! if( 0 == entry.Size ) { return type; } MetricEntry start = _Entry; if( null == start ) { _Entry = entry; } else // tack on data at the end, want to keep x,y at the beginning { while(start.Next != null) { start = start.Next; } start.Next = entry; } _Count++; _size += entry.Size + SerializationHelper.VarSize(entry.Size) + SerializationHelper.VarSize((uint)_Entry.Tag); return type; }
private void InitStylusPointDescription() { int cProps; int cButtons; int pressureIndex = -1; // Make sure we are never called on the application thread when we need to talk // to penimc or else we can cause reentrancy! Debug.Assert(!_contexts._inputSource.Value.CheckAccess()); // We should always have a valid IPimcContext2 interface pointer. Debug.Assert(_pimcContext != null && _pimcContext.Value != null); _pimcContext.Value.GetPacketDescriptionInfo(out cProps, out cButtons); // Calls Unmanaged code - SecurityCritical with SUC. List <StylusPointPropertyInfo> propertyInfos = new List <StylusPointPropertyInfo>(cProps + cButtons + 3); for (int i = 0; i < cProps; i++) { Guid guid; int min, max; int units; float res; _pimcContext.Value.GetPacketPropertyInfo(i, out guid, out min, out max, out units, out res); // Calls Unmanaged code - SecurityCritical with SUC. if (pressureIndex == -1 && guid == StylusPointPropertyIds.NormalPressure) { pressureIndex = i; } if (_statusPropertyIndex == -1 && guid == StylusPointPropertyIds.PacketStatus) { _statusPropertyIndex = i; } StylusPointPropertyInfo propertyInfo = new StylusPointPropertyInfo(new StylusPointProperty(guid, false), min, max, (StylusPointPropertyUnit)units, res); propertyInfos.Add(propertyInfo); } Debug.Assert(_statusPropertyIndex != -1); // We should always see this. // Make sure we actually created propertyInfos OK if (propertyInfos != null) { for (int i = 0; i < cButtons; i++) { Guid buttonGuid; _pimcContext.Value.GetPacketButtonInfo(i, out buttonGuid); // Calls Unmanaged code - SecurityCritical with SUC. StylusPointProperty buttonProperty = new StylusPointProperty(buttonGuid, true); StylusPointPropertyInfo buttonInfo = new StylusPointPropertyInfo(buttonProperty); propertyInfos.Add(buttonInfo); } //validate we can never get X, Y at index != 0, 1 Debug.Assert(propertyInfos[StylusPointDescription.RequiredXIndex /*0*/].Id == StylusPointPropertyIds.X, "X isn't where we expect it! Fix PenImc to ask for X at index 0"); Debug.Assert(propertyInfos[StylusPointDescription.RequiredYIndex /*0*/].Id == StylusPointPropertyIds.Y, "Y isn't where we expect it! Fix PenImc to ask for Y at index 1"); Debug.Assert(pressureIndex == -1 || pressureIndex == StylusPointDescription.RequiredPressureIndex /*2*/, "Fix PenImc to ask for NormalPressure at index 2!"); if (pressureIndex == -1) { //pressure wasn't found. Add it propertyInfos.Insert(StylusPointDescription.RequiredPressureIndex /*2*/, StylusPointPropertyInfoDefaults.NormalPressure); } _infoX = propertyInfos[0]; _infoY = propertyInfos[1]; _stylusPointDescription = new StylusPointDescription(propertyInfos, pressureIndex); } }
/// <summary> /// Internal helper method for comparing compat for two StylusPointPropertyInfos /// </summary> internal static bool AreCompatible(StylusPointPropertyInfo stylusPointPropertyInfo1, StylusPointPropertyInfo stylusPointPropertyInfo2) { if (stylusPointPropertyInfo1 == null || stylusPointPropertyInfo2 == null) { throw new ArgumentNullException("stylusPointPropertyInfo"); } Debug.Assert(( stylusPointPropertyInfo1.Id != StylusPointPropertyIds.X && stylusPointPropertyInfo1.Id != StylusPointPropertyIds.Y && stylusPointPropertyInfo2.Id != StylusPointPropertyIds.X && stylusPointPropertyInfo2.Id != StylusPointPropertyIds.Y), "Why are you checking X, Y for compatibility? They're always compatible"); // // we only take ID and IsButton into account, we don't take metrics into account // return (stylusPointPropertyInfo1.Id == stylusPointPropertyInfo2.Id && stylusPointPropertyInfo1.IsButton == stylusPointPropertyInfo2.IsButton); }